home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet internetowy / Przegladarki internetowe / Mozilla Seamonkey 1.0.5 pl / seamonkey-1.0.5.pl-PL.win32.installer.exe / CHATZILLA.XPI / bin / chrome / chatzilla.jar / content / chatzilla / commands.js < prev    next >
Encoding:
Text File  |  2005-07-10  |  114.9 KB  |  3,875 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  *
  3.  * ***** BEGIN LICENSE BLOCK *****
  4.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  5.  *
  6.  * The contents of this file are subject to the Mozilla Public License Version
  7.  * 1.1 (the "License"); you may not use this file except in compliance with
  8.  * the License. You may obtain a copy of the License at
  9.  * http://www.mozilla.org/MPL/
  10.  *
  11.  * Software distributed under the License is distributed on an "AS IS" basis,
  12.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13.  * for the specific language governing rights and limitations under the
  14.  * License.
  15.  *
  16.  * The Original Code is ChatZilla.
  17.  *
  18.  * The Initial Developer of the Original Code is
  19.  * Netscape Communications Corporation.
  20.  * Portions created by the Initial Developer are Copyright (C) 1998
  21.  * the Initial Developer. All Rights Reserved.
  22.  *
  23.  * Contributor(s):
  24.  *   Robert Ginda, <rginda@netscape.com>, original author
  25.  *   Chiaki Koufugata, chiaki@mozilla.gr.jp, UI i18n
  26.  *
  27.  * Alternatively, the contents of this file may be used under the terms of
  28.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30.  * in which case the provisions of the GPL or the LGPL are applicable instead
  31.  * of those above. If you wish to allow use of your version of this file only
  32.  * under the terms of either the GPL or the LGPL, and not to allow others to
  33.  * use your version of this file under the terms of the MPL, indicate your
  34.  * decision by deleting the provisions above and replace them with the notice
  35.  * and other provisions required by the GPL or the LGPL. If you do not delete
  36.  * the provisions above, a recipient may use your version of this file under
  37.  * the terms of any one of the MPL, the GPL or the LGPL.
  38.  *
  39.  * ***** END LICENSE BLOCK ***** */
  40.  
  41. const CMD_CONSOLE    = 0x01;
  42. const CMD_NEED_NET   = 0x02;
  43. const CMD_NEED_SRV   = 0x04;
  44. const CMD_NEED_CHAN  = 0x08;
  45. const CMD_NEED_USER  = 0x10;
  46. const CMD_NO_HELP    = 0x20;
  47.  
  48. function initCommands()
  49. {
  50.     var cmdary =
  51.         [/* "real" commands */
  52.          ["about",             cmdAbout,                           CMD_CONSOLE],
  53.          ["alias",             cmdAlias,                           CMD_CONSOLE],
  54.          ["attach",            cmdAttach,                          CMD_CONSOLE],
  55.          ["away",              cmdAway,                            CMD_CONSOLE],
  56.          ["back",              cmdAway,                            CMD_CONSOLE],
  57.          ["ban",               cmdBan,             CMD_NEED_CHAN | CMD_CONSOLE],
  58.          ["cancel",            cmdCancel,           CMD_NEED_NET | CMD_CONSOLE],
  59.          ["charset",           cmdCharset,                         CMD_CONSOLE],
  60.          ["channel-motif",     cmdMotif,           CMD_NEED_CHAN | CMD_CONSOLE],
  61.          ["channel-pref",      cmdPref,            CMD_NEED_CHAN | CMD_CONSOLE],
  62.          ["cmd-undo",          "cmd-docommand cmd_undo",                     0],
  63.          ["cmd-redo",          "cmd-docommand cmd_redo",                     0],
  64.          ["cmd-cut",           "cmd-docommand cmd_cut",                      0],
  65.          ["cmd-copy",          "cmd-docommand cmd_copy",                     0],
  66.          ["cmd-paste",         "cmd-docommand cmd_paste",                    0],
  67.          ["cmd-delete",        "cmd-docommand cmd_delete",                   0],
  68.          ["cmd-selectall",     "cmd-docommand cmd_selectAll",                0],
  69.          ["cmd-copy-link-url", "cmd-docommand cmd_copyLink",                 0],
  70.          ["cmd-mozilla-prefs",   "cmd-docommand cmd_mozillaPrefs",           0],
  71.          ["cmd-prefs",           "cmd-docommand cmd_chatzillaPrefs",         0],
  72.          ["cmd-chatzilla-prefs", "cmd-docommand cmd_chatzillaPrefs",         0],
  73.          ["cmd-chatzilla-opts",  "cmd-docommand cmd_chatzillaPrefs",         0],
  74.          ["cmd-docommand",     cmdDoCommand,                                 0],
  75.          ["create-tab-for-view", cmdCreateTabForView,                        0],
  76.          ["custom-away",       cmdAway,                                      0],
  77.          ["op",                cmdChanUserMode,    CMD_NEED_CHAN | CMD_CONSOLE],
  78.          ["dcc-accept",        cmdDCCAccept,                       CMD_CONSOLE],
  79.          ["dcc-chat",          cmdDCCChat,          CMD_NEED_SRV | CMD_CONSOLE],
  80.          ["dcc-close",         cmdDCCClose,                        CMD_CONSOLE],
  81.          ["dcc-decline",       cmdDCCDecline,                      CMD_CONSOLE],
  82.          ["dcc-list",          cmdDCCList,                         CMD_CONSOLE],
  83.          ["dcc-send",          cmdDCCSend,          CMD_NEED_SRV | CMD_CONSOLE],
  84.          ["deop",              cmdChanUserMode,    CMD_NEED_CHAN | CMD_CONSOLE],
  85.          ["describe",          cmdDescribe,         CMD_NEED_SRV | CMD_CONSOLE],
  86.          ["hop",               cmdChanUserMode,    CMD_NEED_CHAN | CMD_CONSOLE],
  87.          ["dehop",             cmdChanUserMode,    CMD_NEED_CHAN | CMD_CONSOLE],
  88.          ["voice",             cmdChanUserMode,    CMD_NEED_CHAN | CMD_CONSOLE],
  89.          ["devoice",           cmdChanUserMode,    CMD_NEED_CHAN | CMD_CONSOLE],
  90.          ["clear-view",        cmdClearView,                       CMD_CONSOLE],
  91.          ["client",            cmdClient,                          CMD_CONSOLE],
  92.          ["commands",          cmdCommands,                        CMD_CONSOLE],
  93.          ["ctcp",              cmdCTCP,             CMD_NEED_SRV | CMD_CONSOLE],
  94.          ["default-charset",   cmdCharset,                         CMD_CONSOLE],
  95.          ["delete-view",       cmdDeleteView,                      CMD_CONSOLE],
  96.          ["disable-plugin",    cmdAblePlugin,                      CMD_CONSOLE],
  97.          ["disconnect",        cmdDisconnect,       CMD_NEED_SRV | CMD_CONSOLE],
  98.          ["disconnect-all",    cmdDisconnectAll,                   CMD_CONSOLE],
  99.          ["echo",              cmdEcho,                            CMD_CONSOLE],
  100.          ["enable-plugin",     cmdAblePlugin,                      CMD_CONSOLE],
  101.          ["eval",              cmdEval,                            CMD_CONSOLE],
  102.          ["find",              cmdFind,                                      0],
  103.          ["find-again",        cmdFindAgain,                                 0],
  104.          ["focus-input",       cmdFocusInput,                                0],
  105.          ["font-family",       cmdFont,                            CMD_CONSOLE],
  106.          ["font-family-other", cmdFont,                                      0],
  107.          ["font-size",         cmdFont,                            CMD_CONSOLE],
  108.          ["font-size-other",   cmdFont,                                      0],
  109.          ["goto-url",          cmdGotoURL,                                   0],
  110.          ["goto-url-newwin",   cmdGotoURL,                                   0],
  111.          ["goto-url-newtab",   cmdGotoURL,                                   0],
  112.          ["goto-url-external", cmdGotoURL,                                   0],
  113.          ["help",              cmdHelp,                            CMD_CONSOLE],
  114.          ["hide-view",         cmdHideView,                        CMD_CONSOLE],
  115.          ["ignore",            cmdIgnore,           CMD_NEED_NET | CMD_CONSOLE],
  116.          ["input-text-direction", cmdInputTextDirection,                     0],
  117.          ["invite",            cmdInvite,           CMD_NEED_SRV | CMD_CONSOLE],
  118.          ["join",              cmdJoin,             CMD_NEED_SRV | CMD_CONSOLE],
  119.          ["join-charset",      cmdJoin,             CMD_NEED_SRV | CMD_CONSOLE],
  120.          ["kick",              cmdKick,            CMD_NEED_CHAN | CMD_CONSOLE],
  121.          ["kick-ban",          cmdKick,            CMD_NEED_CHAN | CMD_CONSOLE],
  122.          ["leave",             cmdLeave,           CMD_NEED_CHAN | CMD_CONSOLE],
  123.          ["links",             cmdSimpleCommand,    CMD_NEED_SRV | CMD_CONSOLE],
  124.          ["list",              cmdList,             CMD_NEED_SRV | CMD_CONSOLE],
  125.          ["list-plugins",      cmdListPlugins,                     CMD_CONSOLE],
  126.          ["load",              cmdLoad,                            CMD_CONSOLE],
  127.          ["log",               cmdLog,                             CMD_CONSOLE],
  128.          ["me",                cmdMe,                              CMD_CONSOLE],
  129.          ["motd",              cmdSimpleCommand,    CMD_NEED_SRV | CMD_CONSOLE],
  130.          ["motif",             cmdMotif,                           CMD_CONSOLE],
  131.          ["msg",               cmdMsg,              CMD_NEED_SRV | CMD_CONSOLE],
  132.          ["names",             cmdNames,            CMD_NEED_SRV | CMD_CONSOLE],
  133.          ["network",           cmdNetwork,                         CMD_CONSOLE],
  134.          ["network-motif",     cmdMotif,            CMD_NEED_NET | CMD_CONSOLE],
  135.          ["network-pref",      cmdPref,             CMD_NEED_NET | CMD_CONSOLE],
  136.          ["networks",          cmdNetworks,                        CMD_CONSOLE],
  137.          ["nick",              cmdNick,                            CMD_CONSOLE],
  138.          ["notice",            cmdNotice,           CMD_NEED_SRV | CMD_CONSOLE],
  139.          ["notify",            cmdNotify,           CMD_NEED_SRV | CMD_CONSOLE],
  140.          ["open-at-startup",   cmdOpenAtStartup,                   CMD_CONSOLE],
  141.          ["pass",              cmdPass,             CMD_NEED_NET | CMD_CONSOLE],
  142.          ["ping",              cmdPing,             CMD_NEED_SRV | CMD_CONSOLE],
  143.          ["plugin-pref",       cmdPref,                            CMD_CONSOLE],
  144.          ["pref",              cmdPref,                            CMD_CONSOLE],
  145.          ["print",             cmdPrint,                           CMD_CONSOLE],
  146.          ["query",             cmdQuery,            CMD_NEED_SRV | CMD_CONSOLE],
  147.          ["quit",              cmdQuit,                            CMD_CONSOLE],
  148.          ["quit-mozilla",      cmdQuitMozilla,                     CMD_CONSOLE],
  149.          ["quote",             cmdQuote,            CMD_NEED_SRV | CMD_CONSOLE],
  150.          ["reload-plugin",     cmdReload,                          CMD_CONSOLE],
  151.          ["rlist",             cmdRlist,            CMD_NEED_SRV | CMD_CONSOLE],
  152.          ["reconnect",         cmdReconnect,        CMD_NEED_NET | CMD_CONSOLE],
  153.          ["reconnect-all",     cmdReconnectAll,                    CMD_CONSOLE],
  154.          ["rejoin",            cmdRejoin,
  155.                                    CMD_NEED_SRV |  CMD_NEED_CHAN | CMD_CONSOLE],
  156.          ["reload-ui",         cmdReloadUI,                                  0],
  157.          ["save",              cmdSave,                            CMD_CONSOLE],
  158.          ["say",               cmdSay,              CMD_NEED_SRV | CMD_CONSOLE],
  159.          ["server",            cmdServer,                          CMD_CONSOLE],
  160.          ["set-current-view",  cmdSetCurrentView,                            0],
  161.          ["squery",            cmdSquery,           CMD_NEED_SRV | CMD_CONSOLE],
  162.          ["sslserver",         cmdSSLServer,                       CMD_CONSOLE],
  163.          ["stalk",             cmdStalk,                           CMD_CONSOLE],
  164.          ["supports",          cmdSupports,         CMD_NEED_SRV | CMD_CONSOLE],
  165.          ["sync-font",         cmdSync,                                      0],
  166.          ["sync-header",       cmdSync,                                      0],
  167.          ["sync-log",          cmdSync,                                      0],
  168.          ["sync-motif",        cmdSync,                                      0],
  169.          ["sync-timestamp",    cmdSync,                                      0],
  170.          ["sync-window",       cmdSync,                                      0],
  171.          ["testdisplay",       cmdTestDisplay,                     CMD_CONSOLE],
  172.          ["text-direction",    cmdTextDirection,                             0],
  173.          ["timestamps",        cmdTimestamps,                      CMD_CONSOLE],
  174.          ["timestamp-format",  cmdTimestampFormat,                 CMD_CONSOLE],
  175.          ["toggle-ui",         cmdToggleUI,                        CMD_CONSOLE],
  176.          ["toggle-pref",       cmdTogglePref,                                0],
  177.          ["topic",             cmdTopic,           CMD_NEED_CHAN | CMD_CONSOLE],
  178.          ["unignore",          cmdIgnore,           CMD_NEED_NET | CMD_CONSOLE],
  179.          ["unban",             cmdBan,             CMD_NEED_CHAN | CMD_CONSOLE],
  180.          ["unstalk",           cmdUnstalk,                         CMD_CONSOLE],
  181.          ["urls",              cmdURLs,                            CMD_CONSOLE],
  182.          ["usermode",          cmdUsermode,                        CMD_CONSOLE],
  183.          ["user-motif",        cmdMotif,           CMD_NEED_USER | CMD_CONSOLE],
  184.          ["user-pref",         cmdPref,            CMD_NEED_USER | CMD_CONSOLE],
  185.          ["version",           cmdVersion,                         CMD_CONSOLE],
  186.          ["who",               cmdWho,              CMD_NEED_SRV | CMD_CONSOLE],
  187.          ["whois",             cmdWhoIs,            CMD_NEED_SRV | CMD_CONSOLE],
  188.          ["whowas",            cmdWhoWas,           CMD_NEED_SRV | CMD_CONSOLE],
  189.          ["wii",               cmdWhoIsIdle,        CMD_NEED_SRV | CMD_CONSOLE],
  190.  
  191.          /* aliases */
  192.          ["css",              "motif",                             CMD_CONSOLE],
  193.          ["exit",             "quit",                              CMD_CONSOLE],
  194.          ["exit-mozilla",     "quit-mozilla",                      CMD_CONSOLE],
  195.          ["desc",             "pref desc",                         CMD_CONSOLE],
  196.          ["j",                "join",                              CMD_CONSOLE],
  197.          ["name",             "pref username",                     CMD_CONSOLE],
  198.          ["part",             "leave",                             CMD_CONSOLE],
  199.          ["raw",              "quote",                             CMD_CONSOLE],
  200.          // Used to display a nickname in the menu only.
  201.          ["label-user",       "echo",                                        0],
  202.          // These are all the font family/size menu commands...
  203.          ["font-family-default",    "font-family default",                   0],
  204.          ["font-family-serif",      "font-family serif",                     0],
  205.          ["font-family-sans-serif", "font-family sans-serif",                0],
  206.          ["font-family-monospace",  "font-family monospace",                 0],
  207.          ["font-size-default",      "font-size default",                     0],
  208.          ["font-size-small",        "font-size small",                       0],
  209.          ["font-size-medium",       "font-size medium",                      0],
  210.          ["font-size-large",        "font-size large",                       0],
  211.          ["font-size-bigger",       "font-size bigger",                      0],
  212.          // This next command is not visible; it maps to Ctrl-=, which is what
  213.          // you get when the user tries to do Ctrl-+ (previous command's key).
  214.          ["font-size-bigger2",      "font-size bigger",                      0],
  215.          ["font-size-smaller",      "font-size smaller",                     0],
  216.          ["toggle-oas",       "open-at-startup toggle",                      0],
  217.          ["toggle-ccm",       "toggle-pref collapseMsgs",                    0],
  218.          ["toggle-copy",      "toggle-pref copyMessages",                    0],
  219.          ["toggle-usort",     "toggle-pref sortUsersByMode",                 0],
  220.          ["toggle-umode",     "toggle-pref showModeSymbols",                 0],
  221.          ["toggle-timestamps","timestamps toggle",                           0],
  222.          ["motif-dark",       "motif dark",                                  0],
  223.          ["motif-light",      "motif light",                                 0],
  224.          ["motif-default",    "motif default",                               0],
  225.          ["sync-output",      "eval syncOutputFrame(this)",                  0],
  226.          ["userlist",         "toggle-ui userlist",                CMD_CONSOLE],
  227.          ["tabstrip",         "toggle-ui tabstrip",                CMD_CONSOLE],
  228.          ["statusbar",        "toggle-ui status",                  CMD_CONSOLE],
  229.          ["header",           "toggle-ui header",                  CMD_CONSOLE],
  230.  
  231.          // text-direction aliases
  232.          ["rtl",              "text-direction rtl",                CMD_CONSOLE],
  233.          ["ltr",              "text-direction ltr",                CMD_CONSOLE],
  234.          ["toggle-text-dir",  "text-direction toggle",                       0],
  235.          ["irtl",             "input-text-direction rtl",          CMD_CONSOLE],
  236.          ["iltr",             "input-text-direction ltr",          CMD_CONSOLE]
  237.         ];
  238.  
  239.     // set the stringbundle associated with these commands.
  240.     cmdary.stringBundle = client.defaultBundle;
  241.  
  242.     client.commandManager = new CommandManager(client.defaultBundle);
  243.     client.commandManager.defaultFlags = CMD_NO_HELP | CMD_CONSOLE;
  244.     client.commandManager.isCommandSatisfied = isCommandSatisfied;
  245.     client.commandManager.defineCommands(cmdary);
  246.  
  247.     var restList = ["reason", "action", "text", "message", "params", "font",
  248.                     "expression", "ircCommand", "prefValue", "newTopic",
  249.                     "commandList", "file", "commands"];
  250.     client.commandManager.argTypes.__aliasTypes__(restList, "rest");
  251.     client.commandManager.argTypes["plugin"] = parsePlugin;
  252. }
  253.  
  254. function isCommandSatisfied(e, command)
  255. {
  256.     if (typeof command == "undefined")
  257.         command = e.command;
  258.     else if (typeof command == "string")
  259.         command = this.commands[command];
  260.  
  261.     if (command.flags & CMD_NEED_USER)
  262.     {
  263.         if (!("user" in e) || !e.user)
  264.         {
  265.             e.parseError = getMsg(MSG_ERR_NEED_USER, command.name);
  266.             return false;
  267.         }
  268.     }
  269.  
  270.     if (command.flags & CMD_NEED_CHAN)
  271.     {
  272.         if (!("channel" in e) || !e.channel)
  273.         {
  274.             e.parseError = getMsg(MSG_ERR_NEED_CHANNEL, command.name);
  275.             return false;
  276.         }
  277.     }
  278.  
  279.     if (command.flags & CMD_NEED_SRV)
  280.     {
  281.         if (!("server" in e) || !e.server)
  282.         {
  283.             e.parseError = getMsg(MSG_ERR_NEED_SERVER, command.name);
  284.             return false;
  285.         }
  286.  
  287.         if (e.network.state != NET_ONLINE)
  288.         {
  289.             e.parseError = MSG_ERR_NOT_CONNECTED;
  290.             return false;
  291.         }
  292.     }
  293.  
  294.     if (command.flags & (CMD_NEED_NET | CMD_NEED_SRV | CMD_NEED_CHAN))
  295.     {
  296.         if (!("network" in e) || !e.network)
  297.         {
  298.             e.parseError = getMsg(MSG_ERR_NEED_NETWORK, command.name);
  299.             return false;
  300.         }
  301.     }
  302.  
  303.     return CommandManager.prototype.isCommandSatisfied(e, command);
  304. }
  305.  
  306. CIRCChannel.prototype.dispatch =
  307. CIRCNetwork.prototype.dispatch =
  308. CIRCUser.prototype.dispatch =
  309. CIRCDCCChat.prototype.dispatch =
  310. CIRCDCCFileTransfer.prototype.dispatch =
  311. client.dispatch =
  312. function this_dispatch(text, e, isInteractive, flags)
  313. {
  314.     e = getObjectDetails(this, e);
  315.     return dispatch(text, e, isInteractive, flags);
  316. }
  317.  
  318. function dispatch(text, e, isInteractive, flags)
  319. {
  320.     if (typeof isInteractive == "undefined")
  321.         isInteractive = false;
  322.  
  323.     if (!e)
  324.         e = new Object();
  325.  
  326.     if (!("sourceObject" in e))
  327.         e.__proto__ = getObjectDetails(client.currentObject);
  328.  
  329.     if (!("isInteractive" in e))
  330.         e.isInteractive = isInteractive;
  331.  
  332.     if (!("inputData" in e))
  333.         e.inputData = "";
  334.  
  335.     /* split command from arguments */
  336.     var ary = text.match(/(\S+) ?(.*)/);
  337.     e.commandText = ary[1];
  338.     if (ary[2])
  339.         e.inputData = stringTrim(ary[2]);
  340.  
  341.     /* list matching commands */
  342.     ary = client.commandManager.list(e.commandText, flags);
  343.     var rv = null;
  344.     var i;
  345.  
  346.     switch (ary.length)
  347.     {
  348.         case 0:
  349.             /* no match, try again */
  350.             if (e.server && e.server.isConnected &&
  351.                 client.prefs["guessCommands"])
  352.             {
  353.                 /* Want to keep the source details. */
  354.                 var e2 = getObjectDetails(e.sourceObject);
  355.                 e2.inputData = e.commandText + " " + e.inputData;
  356.                 return dispatch("quote", e2);
  357.             }
  358.  
  359.             display(getMsg(MSG_NO_CMDMATCH, e.commandText), MT_ERROR);
  360.             break;
  361.  
  362.         case 1:
  363.             /* one match, good for you */
  364.             var ex;
  365.             try
  366.             {
  367.                 rv = dispatchCommand(ary[0], e, flags);
  368.             }
  369.             catch (ex)
  370.             {
  371.                 display(getMsg(MSG_ERR_INTERNAL_DISPATCH, ary[0].name),
  372.                         MT_ERROR);
  373.                 display(formatException(ex), MT_ERROR);
  374.                 if (typeof ex == "object" && "stack" in ex)
  375.                     dd(formatException(ex) + "\n" + ex.stack);
  376.                 else
  377.                     dd(formatException(ex), MT_ERROR);
  378.             }
  379.             break;
  380.  
  381.         default:
  382.             /* more than one match, show the list */
  383.             var str = "";
  384.             for (i in ary)
  385.                 str += (str) ? MSG_COMMASP + ary[i].name : ary[i].name;
  386.             display(getMsg(MSG_ERR_AMBIGCOMMAND,
  387.                            [e.commandText, ary.length, str]), MT_ERROR);
  388.     }
  389.  
  390.     return rv;
  391. }
  392.  
  393. function dispatchCommand (command, e, flags)
  394. {
  395.     function displayUsageError (e, details)
  396.     {
  397.         if (!("isInteractive" in e) || !e.isInteractive)
  398.         {
  399.             var caller = Components.stack.caller.caller;
  400.             if (caller.name == "dispatch")
  401.                 caller = caller.caller;
  402.             var error = new Error (details);
  403.             error.fileName = caller.filename;
  404.             error.lineNumber = caller.lineNumber;
  405.             error.name = caller.name;
  406.             display (formatException(error), MT_ERROR);
  407.         }
  408.         else
  409.         {
  410.             display (details, MT_ERROR);
  411.         }
  412.  
  413.         //display (getMsg(MSG_FMT_USAGE, [e.command.name, e.command.usage]),
  414.         //         MT_USAGE);
  415.     };
  416.  
  417.     function callHooks (command, isBefore)
  418.     {
  419.         var names, hooks;
  420.  
  421.         if (isBefore)
  422.             hooks = command.beforeHooks;
  423.         else
  424.             hooks = command.afterHooks;
  425.  
  426.         for (var h in hooks)
  427.         {
  428.             if ("dbgDispatch" in client && client.dbgDispatch)
  429.             {
  430.                 dd ("calling " + (isBefore ? "before" : "after") +
  431.                     " hook " + h);
  432.             }
  433.             try
  434.             {
  435.                 hooks[h](e);
  436.             }
  437.             catch (ex)
  438.             {
  439.                 if (e.command.name != "hook-session-display")
  440.                 {
  441.                     display(getMsg(MSG_ERR_INTERNAL_HOOK, h), MT_ERROR);
  442.                     display(formatException(ex), MT_ERROR);
  443.                 }
  444.                 else
  445.                 {
  446.                     dd(getMsg(MSG_ERR_INTERNAL_HOOK, h));
  447.                 }
  448.  
  449.                 dd("Caught exception calling " +
  450.                    (isBefore ? "before" : "after") + " hook " + h);
  451.                 dd(formatException(ex));
  452.                 if (typeof ex == "object" && "stack" in ex)
  453.                     dd(ex.stack);
  454.                 else
  455.                     dd(getStackTrace());
  456.             }
  457.         }
  458.     };
  459.  
  460.     e.command = command;
  461.  
  462.     if (!e.command.enabled)
  463.     {
  464.         /* disabled command */
  465.         display (getMsg(MSG_ERR_DISABLED, e.command.name),
  466.                  MT_ERROR);
  467.         return null;
  468.     }
  469.  
  470.     function parseAlias(aliasLine, e) {
  471.         /* Only 1 of these will be presented to the user. Math.max is used to
  472.            supply the 'worst' error */
  473.         const ALIAS_ERR_REQ_PRMS = 1;
  474.         const ALIAS_ERR_REQ_SRV = 2;
  475.         const ALIAS_ERR_REQ_RECIP = 3;
  476.  
  477.         /* double slashes because of the string to regexp conversion, which
  478.            turns these into single slashes */
  479.         const SIMPLE_REPLACE = "\\$\\((\\d+)\\)";
  480.         const CUMUL_REPLACE = "\\$\\((\\d+)\\+\\)";
  481.         const RANGE_REPLACE = "\\$\\((\\d+)\\-(\\d+)\\)";
  482.         const NICK_REPLACE = "\\$\\((nick)\\)";
  483.         const RECIP_REPLACE = "\\$\\((recip)\\)";
  484.         const ALL_REPLACE = "\\$\\((all)\\)";
  485.         if (!aliasLine.match(/\$/))
  486.         {
  487.             if (e.inputData)
  488.                 display(getMsg(MSG_EXTRA_PARAMS, e.inputData), MT_WARN);
  489.             return aliasLine;
  490.         }
  491.  
  492.         function replaceAll(match, single, cumulative, start, end, nick, recip, all)
  493.         {
  494.             if (single)
  495.             {
  496.                 // Simple 1-parameter replace
  497.                 if (arrayHasElementAt(parameters, single - 1))
  498.                 {
  499.                     paramsUsed = Math.max(paramsUsed, single);
  500.                     return parameters[single-1];
  501.                 }
  502.                 maxParamsAsked = Math.max(maxParamsAsked, single);
  503.                 errorMsg = Math.max(ALIAS_ERR_REQ_PRMS, errorMsg);
  504.                 return match;
  505.             }
  506.             if (cumulative)
  507.             {
  508.                 // Cumulative Replace: parameters cumulative and up
  509.                 if (arrayHasElementAt(parameters, cumulative - 1))
  510.                 {
  511.                     paramsUsed = parameters.length;
  512.                     // there are never leftover parameters for $(somenumber+)
  513.                     return parameters.slice(cumulative - 1).join(" ");
  514.                 }
  515.                 maxParamsAsked = Math.max(maxParamsAsked, cumulative);
  516.                 errorMsg = Math.max(ALIAS_ERR_REQ_PRMS, errorMsg);
  517.                 return match;
  518.             }
  519.             if (start && end)
  520.             {
  521.                 // Ranged replace: parameters start through end
  522.                 //'decrement to correct 0-based index.
  523.                 if (start > end)
  524.                 {
  525.                     var iTemp = end;
  526.                     end = start;
  527.                     start = iTemp;
  528.                     // We obviously have a very stupid user, but we're nice
  529.                 }
  530.                 start--;
  531.                 if (arrayHasElementAt(parameters, start) &&
  532.                     arrayHasElementAt(parameters, end - 1))
  533.                 {
  534.                     paramsUsed = Math.max(paramsUsed,end);
  535.                     return parameters.slice(start, end).join(" ");
  536.                 }
  537.                 maxParamsAsked = Math.max(maxParamsAsked, end);
  538.                 errorMsg = Math.max(ALIAS_ERR_REQ_PRMS, errorMsg);
  539.                 return match;
  540.             }
  541.             if (nick)
  542.             {
  543.                 // Replace with own nickname
  544.                 if (e.network && e.server && e.network.state == NET_ONLINE)
  545.                     return e.server.me.unicodeName;
  546.  
  547.                 errorMsg = Math.max(ALIAS_ERR_REQ_SRV, errorMsg);
  548.                 return null;
  549.             }
  550.             if (recip)
  551.             {
  552.                 // Replace with current recipient
  553.                 if (e.channel)
  554.                     return e.channel.unicodeName;
  555.  
  556.                 if (e.user)
  557.                     return e.user.unicodeName;
  558.  
  559.                 errorMsg = ALIAS_ERR_REQ_RECIP;
  560.                 return null;
  561.              }
  562.              // Replace with all parameters
  563.              paramsUsed = parameters.length;
  564.              return parameters.join(" ");
  565.         };
  566.  
  567.         // If the replace function has a problem, this is an error constant:
  568.         var errorMsg = 0;
  569.  
  570.         var paramsUsed = 0;
  571.         var maxParamsAsked = 0;
  572.  
  573.         /* set parameters array and escaping \ and ; in parameters so the
  574.          * parameters don't get split up by the command list split later on */
  575.         e.inputData = e.inputData.replace(/([\\;])/g, "\\$1");
  576.         var parameters = e.inputData.match(/\S+/g);
  577.         if (!parameters)
  578.             parameters = [];
  579.  
  580.         // replace in the command line.
  581.         var expr = [SIMPLE_REPLACE, CUMUL_REPLACE, RANGE_REPLACE, NICK_REPLACE,
  582.                     RECIP_REPLACE, ALL_REPLACE].join("|");
  583.         aliasLine = aliasLine.replace(new RegExp(expr, "gi"), replaceAll);
  584.  
  585.         if (errorMsg)
  586.         {
  587.             switch (errorMsg)
  588.             {
  589.                 case ALIAS_ERR_REQ_PRMS:
  590.                     display(getMsg(MSG_ERR_REQUIRED_NR_PARAM,
  591.                                    [maxParamsAsked - parameters.length,
  592.                                     maxParamsAsked]), MT_ERROR);
  593.                     break;
  594.                 case ALIAS_ERR_REQ_SRV:
  595.                     display(getMsg(MSG_ERR_NEED_SERVER, e.command.name),
  596.                             MT_ERROR);
  597.                     break;
  598.                 case ALIAS_ERR_REQ_RECIP:
  599.                     display(getMsg(MSG_ERR_NEED_RECIP, e.command.name),
  600.                             MT_ERROR);
  601.                     break;
  602.             }
  603.             return null;
  604.         }
  605.  
  606.         // return the revised command line.
  607.         if (paramsUsed < parameters.length)
  608.         {
  609.             var pmstring = parameters.slice(paramsUsed,
  610.                                             parameters.length).join(" ");
  611.             display(getMsg(MSG_EXTRA_PARAMS, pmstring), MT_WARN);
  612.         }
  613.         return aliasLine;
  614.     };
  615.  
  616.     var h, i;
  617.  
  618.     if (typeof e.command.func == "function")
  619.     {
  620.         /* dispatch a real function */
  621.         if (e.command.usage)
  622.             client.commandManager.parseArguments (e);
  623.         if ("parseError" in e)
  624.         {
  625.             displayUsageError(e, e.parseError);
  626.         }
  627.         else
  628.         {
  629.             if ("beforeHooks" in e.command)
  630.                 callHooks (e.command, true);
  631.  
  632.             if ("dbgDispatch" in client && client.dbgDispatch)
  633.             {
  634.                 var str = "";
  635.                 for (i = 0; i < e.command.argNames.length; ++i)
  636.                 {
  637.                     var name = e.command.argNames[i];
  638.                     if (name in e)
  639.                         str += " " + name + ": " + e[name];
  640.                     else if (name != ":")
  641.                         str += " ?" + name;
  642.                 }
  643.                 dd (">>> " + e.command.name + str + " <<<");
  644.                 e.returnValue = e.command.func(e);
  645.                 /* set client.lastEvent *after* dispatching, so the dispatched
  646.                  * function actually get's a chance to see the last event. */
  647.                 client.lastEvent = e;
  648.             }
  649.             else
  650.             {
  651.                 e.returnValue = e.command.func(e);
  652.             }
  653.  
  654.         }
  655.     }
  656.     else if (typeof e.command.func == "string")
  657.     {
  658.         /* dispatch an alias (semicolon delimited list of subcommands) */
  659.         if ("beforeHooks" in e.command)
  660.             callHooks (e.command, true);
  661.  
  662.         var commandList;
  663.         //Don't make use of e.inputData if we have multiple commands in 1 alias
  664.         if (e.command.func.match(/\$\(.*\)|(?:^|[^\\])(?:\\\\)*;/))
  665.             commandList = parseAlias(e.command.func, e);
  666.         else
  667.             commandList = e.command.func + " " + e.inputData;
  668.  
  669.         if (commandList == null)
  670.             return null;
  671.         commandList = commandList.split(";");
  672.  
  673.         i = 0;
  674.         while (i < commandList.length) {
  675.             if (commandList[i].match(/(?:^|[^\\])(?:\\\\)*$/) ||
  676.                 (i == commandList.length - 1))
  677.             {
  678.                 commandList[i] = commandList[i].replace(/\\(.)/g, "$1");
  679.                 i++;
  680.             }
  681.             else
  682.             {
  683.                 commandList[i] = commandList[i] + ";" + commandList[i + 1];
  684.                 commandList.splice(i + 1, 1);
  685.             }
  686.         }
  687.  
  688.         for (i = 0; i < commandList.length; ++i)
  689.         {
  690.             var newEvent = Clone(e);
  691.             delete newEvent.command;
  692.             commandList[i] = stringTrim(commandList[i]);
  693.             dispatch(commandList[i], newEvent, flags);
  694.         }
  695.     }
  696.     else
  697.     {
  698.         display (getMsg(MSG_ERR_NOTIMPLEMENTED, e.command.name),
  699.                  MT_ERROR);
  700.         return null;
  701.     }
  702.  
  703.     if ("afterHooks" in e.command)
  704.         callHooks (e.command, false);
  705.  
  706.     return ("returnValue" in e) ? e.returnValue : null;
  707. }
  708.  
  709. /* parse function for <plugin> parameters */
  710. function parsePlugin(e, name)
  711. {
  712.     var ary = e.unparsedData.match (/(?:(\d+)|(\S+))(?:\s+(.*))?$/);
  713.     if (!ary)
  714.         return false;
  715.  
  716.     var plugin;
  717.  
  718.     if (ary[1])
  719.     {
  720.         var i = parseInt(ary[1]);
  721.         if (!(i in client.plugins))
  722.             return false;
  723.  
  724.         plugin = client.plugins[i];
  725.     }
  726.     else
  727.     {
  728.         plugin = getPluginById(ary[2]);
  729.         if (!plugin)
  730.             return false;
  731.  
  732.     }
  733.  
  734.     e.unparsedData = arrayHasElementAt(ary, 3) ? ary[3] : "";
  735.     e[name] = plugin;
  736.     return true;
  737. }
  738.  
  739. function getToggle (toggle, currentState)
  740. {
  741.     if (toggle == "toggle")
  742.         toggle = !currentState;
  743.  
  744.     return toggle;
  745. }
  746.  
  747. /******************************************************************************
  748.  * command definitions from here on down.
  749.  */
  750.  
  751. function cmdAblePlugin(e)
  752. {
  753.     if (e.command.name == "disable-plugin")
  754.     {
  755.         if (!e.plugin.enabled)
  756.         {
  757.             display(getMsg(MSG_IS_DISABLED, e.plugin.id));
  758.             return;
  759.         }
  760.  
  761.         if (e.plugin.API > 0)
  762.         {
  763.             if (!e.plugin.disable())
  764.             {
  765.                 display(getMsg(MSG_CANT_DISABLE, e.plugin.id));
  766.                 return;
  767.             }
  768.             e.plugin.prefs["enabled"] = false;
  769.         }
  770.         else if (!("disablePlugin" in e.plugin.scope))
  771.         {
  772.             display(getMsg(MSG_CANT_DISABLE, e.plugin.id));
  773.             return;
  774.         }
  775.         else
  776.         {
  777.             e.plugin.scope.disablePlugin();
  778.         }
  779.  
  780.         e.plugin.enabled = false;
  781.     }
  782.     else
  783.     {
  784.         if (e.plugin.enabled)
  785.         {
  786.             display(getMsg(MSG_IS_ENABLED, e.plugin.id));
  787.             return;
  788.         }
  789.  
  790.         if (e.plugin.API > 0)
  791.         {
  792.             if (!e.plugin.enable())
  793.             {
  794.                 display(getMsg(MSG_CANT_ENABLE, e.plugin.id));
  795.                 e.plugin.prefs["enabled"] = false;
  796.                 return;
  797.             }
  798.             e.plugin.prefs["enabled"] = true;
  799.         }
  800.         else if (!("enablePlugin" in e.plugin.scope))
  801.         {
  802.             display(getMsg(MSG_CANT_ENABLE, e.plugin.id));
  803.             return;
  804.         }
  805.         else
  806.         {
  807.             e.plugin.scope.enablePlugin();
  808.         }
  809.  
  810.         e.plugin.enabled = true;
  811.     }
  812. }
  813.  
  814. function cmdBan(e)
  815. {
  816.     /* If we're unbanning, or banning in odd cases, we may actually be talking
  817.      * about a user who is not in the channel, so we need to check the server
  818.      * for information as well.
  819.      */
  820.     if (!e.user)
  821.         e.user = e.channel.getUser(e.nickname);
  822.     if (!e.user)
  823.         e.user = e.server.getUser(e.nickname);
  824.  
  825.     var mask;
  826.     if (e.user)
  827.     {
  828.         // We have a real user object, so get their proper 'ban mask'.
  829.         mask = e.user.getBanMask();
  830.     }
  831.     else
  832.     {
  833.         /* If we have either ! or @ in the nickname assume the user has given
  834.          * us a complete mask and pass it directly, otherwise assume it is
  835.          * only the nickname and use * for username/host.
  836.          */
  837.         mask = fromUnicode(e.nickname, e.server);
  838.         if (!/[!@]/.test(e.nickname))
  839.             mask = mask + "!*@*";
  840.     }
  841.  
  842.     var op = (e.command.name == "unban") ? " -b " : " +b ";
  843.     e.server.sendData("MODE " + e.channel.encodedName + op + mask + "\n");
  844. }
  845.  
  846. function cmdCancel(e)
  847. {
  848.     var network = e.network;
  849.  
  850.     if ((network.state != NET_CONNECTING) && (network.state != NET_WAITING))
  851.     {
  852.         display(MSG_NOTHING_TO_CANCEL, MT_ERROR);
  853.         return;
  854.     }
  855.  
  856.     display(getMsg(MSG_CANCELLING, network.unicodeName));
  857.     network.cancel();
  858. }
  859.  
  860. function cmdChanUserMode(e)
  861. {
  862.     var modestr;
  863.     switch (e.command.name)
  864.     {
  865.         case "op":
  866.             modestr = "+oooo";
  867.             break;
  868.  
  869.         case "deop":
  870.             modestr = "-oooo";
  871.             break;
  872.  
  873.         case "hop":
  874.             modestr = "+hhhh";
  875.             break;
  876.  
  877.         case "dehop":
  878.             modestr = "-hhhh";
  879.             break;
  880.  
  881.         case "voice":
  882.             modestr = "+vvvv";
  883.             break;
  884.  
  885.         case "devoice":
  886.             modestr = "-vvvv";
  887.             break;
  888.  
  889.         default:
  890.             ASSERT(0, "Dispatch from unknown name " + e.command.name);
  891.             return;
  892.     }
  893.  
  894.     var nicks;
  895.     var user;
  896.     // Prefer pre-canonicalised list, then a normal list, then finally a
  897.     // sigular item (canon. or otherwise).
  898.     if (e.canonNickList)
  899.     {
  900.         nicks = combineNicks(e.canonNickList);
  901.     }
  902.     else if (e.nicknameList)
  903.     {
  904.         var nickList = new Array();
  905.         for (i = 0; i < e.nicknameList.length; i++)
  906.         {
  907.             user = e.channel.getUser(e.nicknameList[i]);
  908.             if (!user)
  909.             {
  910.                 display(getMsg(MSG_ERR_UNKNOWN_USER, e.nicknameList[i]), MT_ERROR);
  911.                 return;
  912.             }
  913.             nickList.push(user.encodedName);
  914.         }
  915.         nicks = combineNicks(nickList);
  916.     }
  917.     else if (e.nickname)
  918.     {
  919.         user = e.channel.getUser(e.nickname);
  920.         if (!user)
  921.         {
  922.             display(getMsg(MSG_ERR_UNKNOWN_USER, e.nickname), MT_ERROR);
  923.             return;
  924.         }
  925.         var str = new String(user.encodedName);
  926.         str.count = 1;
  927.         nicks = [str];
  928.     }
  929.     else
  930.     {
  931.         // Panic?
  932.         dd("Help! Channel user mode command with no users...?");
  933.     }
  934.  
  935.     for (var i = 0; i < nicks.length; ++i)
  936.     {
  937.         e.server.sendData("MODE " + e.channel.encodedName + " " +
  938.                           modestr.substr(0, nicks[i].count + 1) +
  939.                           " " + nicks[i] + "\n");
  940.     }
  941. }
  942.  
  943. function cmdCharset(e)
  944. {
  945.     var pm;
  946.  
  947.     if (e.command.name == "default-charset")
  948.     {
  949.         pm = client.prefManager;
  950.         msg = MSG_CURRENT_CHARSET;
  951.     }
  952.     else
  953.     {
  954.         pm = e.sourceObject.prefManager;
  955.         msg = MSG_CURRENT_CHARSET_VIEW;
  956.     }
  957.  
  958.     if (e.newCharset)
  959.     {
  960.         if (e.newCharset == "-")
  961.         {
  962.             pm.clearPref("charset");
  963.         }
  964.         else
  965.         {
  966.             if(!checkCharset(e.newCharset))
  967.             {
  968.                 display(getMsg(MSG_ERR_INVALID_CHARSET, e.newCharset),
  969.                         MT_ERROR);
  970.                 return;
  971.             }
  972.             pm.prefs["charset"] = e.newCharset;
  973.         }
  974.     }
  975.  
  976.     display(getMsg(msg, pm.prefs["charset"]));
  977.  
  978.     // If we're on a channel, get the topic again so it can be re-decoded.
  979.     if (e.newCharset && e.server && e.channel)
  980.         e.server.sendData("TOPIC " + e.channel.encodedName + "\n");
  981. }
  982.  
  983. function cmdCreateTabForView(e)
  984. {
  985.     return getTabForObject(e.view, true);
  986. }
  987.  
  988. function cmdSync(e)
  989. {
  990.     var fun;
  991.  
  992.     switch (e.command.name)
  993.     {
  994.         case "sync-font":
  995.             fun = function ()
  996.                   {
  997.                       if (view.prefs["displayHeader"])
  998.                           view.setHeaderState(false);
  999.                       view.changeCSS(view.getFontCSS("data"),
  1000.                                      "cz-fonts");
  1001.                       if (view.prefs["displayHeader"])
  1002.                           view.setHeaderState(true);
  1003.                   };
  1004.             break;
  1005.  
  1006.         case "sync-header":
  1007.             fun = function ()
  1008.                   {
  1009.                       view.setHeaderState(view.prefs["displayHeader"]);
  1010.                   };
  1011.             break;
  1012.  
  1013.         case "sync-motif":
  1014.             fun = function ()
  1015.                   {
  1016.                       view.changeCSS(view.prefs["motif.current"]);
  1017.                   };
  1018.             break;
  1019.  
  1020.         case "sync-timestamp":
  1021.             fun = function ()
  1022.                   {
  1023.                       view.changeCSS(view.getTimestampCSS("data"),
  1024.                                      "cz-timestamp-format");
  1025.                   };
  1026.             break;
  1027.  
  1028.         case "sync-window":
  1029.             fun = function ()
  1030.                   {
  1031.                       if (window && window.location &&
  1032.                           window.location.href != view.prefs["outputWindowURL"])
  1033.                       {
  1034.                           syncOutputFrame(view);
  1035.                       }
  1036.                   };
  1037.             break;
  1038.  
  1039.         case "sync-log":
  1040.             fun = function ()
  1041.                   {
  1042.                       if (view.prefs["log"] ^ Boolean(view.logFile))
  1043.                       {
  1044.                           if (view.prefs["log"])
  1045.                               client.openLogFile(view);
  1046.                           else
  1047.                               client.closeLogFile(view);
  1048.                       }
  1049.                   };
  1050.             break;
  1051.     }
  1052.  
  1053.     var view = e.sourceObject;
  1054.     var window;
  1055.     if (("frame" in view) && view.frame)
  1056.         window = view.frame.contentWindow;
  1057.  
  1058.     try
  1059.     {
  1060.         fun();
  1061.     }
  1062.     catch(ex)
  1063.     {
  1064.         dd("Exception in " + e.command.name + " for " + e.sourceObject.unicodeName + ": " + ex);
  1065.     }
  1066. }
  1067.  
  1068. function cmdSimpleCommand(e)
  1069. {
  1070.     e.server.sendData(e.command.name + " " + e.inputData + "\n");
  1071. }
  1072.  
  1073. function cmdSquery(e)
  1074. {
  1075.     var data;
  1076.  
  1077.     if (e.commands)
  1078.         data = "SQUERY " + e.service + " :" + e.commands + "\n";
  1079.     else
  1080.         data = "SQUERY " + e.service + "\n";
  1081.  
  1082.     e.server.sendData(data);
  1083. }
  1084.  
  1085. function cmdStatus(e)
  1086. {
  1087.     function serverStatus (s)
  1088.     {
  1089.         if (!s.connection.isConnected)
  1090.         {
  1091.             display(getMsg(MSG_NOT_CONNECTED, s.parent.name), MT_STATUS);
  1092.             return;
  1093.         }
  1094.  
  1095.         var serverType = (s.parent.primServ == s) ? MSG_PRIMARY : MSG_SECONDARY;
  1096.         display(getMsg(MSG_CONNECTION_INFO,
  1097.                        [s.parent.name, s.me.unicodeName, s.connection.host,
  1098.                         s.connection.port, serverType]),
  1099.                 MT_STATUS);
  1100.  
  1101.         var connectTime = Math.floor((new Date() - s.connection.connectDate) /
  1102.                                      1000);
  1103.         connectTime = formatDateOffset(connectTime);
  1104.  
  1105.         var pingTime = ("lastPing" in s) ?
  1106.             formatDateOffset(Math.floor((new Date() - s.lastPing) / 1000)) :
  1107.             MSG_NA;
  1108.         var lag = (s.lag >= 0) ? s.lag : MSG_NA;
  1109.  
  1110.         display(getMsg(MSG_SERVER_INFO,
  1111.                        [s.parent.name, connectTime, pingTime, lag]),
  1112.                 MT_STATUS);
  1113.     }
  1114.  
  1115.     function channelStatus (c)
  1116.     {
  1117.         var cu;
  1118.         var net = c.parent.parent.name;
  1119.  
  1120.         if ((cu = c.users[c.parent.me.canonicalName]))
  1121.         {
  1122.             var mtype;
  1123.  
  1124.             if (cu.isOp && cu.isVoice)
  1125.                 mtype = MSG_VOICEOP;
  1126.             else if (cu.isOp)
  1127.                 mtype = MSG_OPERATOR;
  1128.             else if (cu.isVoice)
  1129.                 mtype = MSG_VOICED;
  1130.             else
  1131.                 mtype = MSG_MEMBER;
  1132.  
  1133.             var mode = c.mode.getModeStr();
  1134.             if (!mode)
  1135.                 mode = MSG_NO_MODE;
  1136.  
  1137.             display(getMsg(MSG_CHANNEL_INFO,
  1138.                            [net, mtype, c.unicodeName, mode,
  1139.                             (c.parent.isSecure ? "irc://" : "ircs://" )
  1140.                              + escape(net) + "/" + escape(c.encodedName) + "/"]),
  1141.                     MT_STATUS);
  1142.             display(getMsg(MSG_CHANNEL_DETAIL,
  1143.                            [net, c.unicodeName, c.getUsersLength(),
  1144.                             c.opCount, c.voiceCount]),
  1145.                     MT_STATUS);
  1146.  
  1147.             if (c.topic)
  1148.             {
  1149.                 display(getMsg(MSG_TOPIC_INFO, [net, c.unicodeName, c.topic]),
  1150.                          MT_STATUS);
  1151.             }
  1152.             else
  1153.             {
  1154.                 display(getMsg(MSG_NOTOPIC_INFO, [net, c.unicodeName]),
  1155.                         MT_STATUS);
  1156.             }
  1157.         }
  1158.         else
  1159.         {
  1160.             display(getMsg(MSG_NONMEMBER, [net, c.unicodeName]), MT_STATUS);
  1161.         }
  1162.     };
  1163.  
  1164.     display(client.userAgent, MT_STATUS);
  1165.     display(getMsg(MSG_USER_INFO,
  1166.                    [client.prefs["nickname"], client.prefs["username"],
  1167.                     client.prefs["desc"]]),
  1168.             MT_STATUS);
  1169.  
  1170.     var n, s, c;
  1171.  
  1172.     if (e.channel)
  1173.     {
  1174.         serverStatus(e.server);
  1175.         channelStatus(e.channel);
  1176.     }
  1177.     else if (e.network)
  1178.     {
  1179.         for (s in e.network.servers)
  1180.         {
  1181.             serverStatus(e.network.servers[s]);
  1182.             for (c in e.network.servers[s].channels)
  1183.                 channelStatus (e.network.servers[s].channels[c]);
  1184.         }
  1185.     }
  1186.     else
  1187.     {
  1188.         for (n in client.networks)
  1189.         {
  1190.             for (s in client.networks[n].servers)
  1191.             {
  1192.                 var server = client.networks[n].servers[s]
  1193.                     serverStatus(server);
  1194.                 for (c in server.channels)
  1195.                     channelStatus(server.channels[c]);
  1196.             }
  1197.         }
  1198.     }
  1199.  
  1200.     display(MSG_END_STATUS, MT_STATUS);
  1201. }
  1202.  
  1203. function cmdHelp (e)
  1204. {
  1205.     var ary;
  1206.     ary = client.commandManager.list (e.pattern, CMD_CONSOLE);
  1207.  
  1208.     if (ary.length == 0)
  1209.     {
  1210.         display (getMsg(MSG_ERR_NO_COMMAND, e.pattern), MT_ERROR);
  1211.         return false;
  1212.     }
  1213.  
  1214.     for (var i in ary)
  1215.     {
  1216.         display (getMsg(MSG_FMT_USAGE, [ary[i].name, ary[i].usage]), MT_USAGE);
  1217.         display (ary[i].help, MT_HELP);
  1218.     }
  1219.  
  1220.     return true;
  1221. }
  1222.  
  1223. function cmdTestDisplay(e)
  1224. {
  1225.     display(MSG_TEST_HELLO, MT_HELLO);
  1226.     display(MSG_TEST_INFO, MT_INFO);
  1227.     display(MSG_TEST_ERROR, MT_ERROR);
  1228.     display(MSG_TEST_HELP, MT_HELP);
  1229.     display(MSG_TEST_USAGE, MT_USAGE);
  1230.     display(MSG_TEST_STATUS, MT_STATUS);
  1231.  
  1232.     if (e.server && e.server.me)
  1233.     {
  1234.         var me = e.server.me;
  1235.         var sampleUser = {TYPE: "IRCUser",
  1236.                           encodedName: "ircmonkey", canonicalName: "ircmonkey",
  1237.                           unicodeName: "IRCMonkey", viewName: "IRCMonkey",
  1238.                           host: "", name: "chatzilla"};
  1239.         var sampleChannel = {TYPE: "IRCChannel",
  1240.                              encodedName: "#mojo", canonicalName: "#mojo",
  1241.                              unicodeName: "#Mojo", viewName: "#Mojo"};
  1242.  
  1243.         function test (from, to)
  1244.         {
  1245.             var fromText = (from != me) ? from.TYPE + " ``" + from.name + "''" :
  1246.                 MSG_YOU;
  1247.             var toText   = (to != me) ? to.TYPE + " ``" + to.name + "''" :
  1248.                 MSG_YOU;
  1249.  
  1250.             display (getMsg(MSG_TEST_PRIVMSG, [fromText, toText]),
  1251.                      "PRIVMSG", from, to);
  1252.             display (getMsg(MSG_TEST_ACTION, [fromText, toText]),
  1253.                      "ACTION", from, to);
  1254.             display (getMsg(MSG_TEST_NOTICE, [fromText, toText]),
  1255.                      "NOTICE", from, to);
  1256.         }
  1257.  
  1258.         test (sampleUser, me); /* from user to me */
  1259.         test (me, sampleUser); /* me to user */
  1260.  
  1261.         display(MSG_TEST_URL, "PRIVMSG", sampleUser, me);
  1262.         display(MSG_TEST_STYLES, "PRIVMSG", sampleUser, me);
  1263.         display(MSG_TEST_EMOTICON, "PRIVMSG", sampleUser, me);
  1264.         display(MSG_TEST_RHEET, "PRIVMSG", sampleUser, me);
  1265.         display(unescape(MSG_TEST_CTLCHR), "PRIVMSG", sampleUser, me);
  1266.         display(unescape(MSG_TEST_COLOR), "PRIVMSG", sampleUser, me);
  1267.         display(MSG_TEST_QUOTE, "PRIVMSG", sampleUser, me);
  1268.  
  1269.         if (e.channel)
  1270.         {
  1271.             test (sampleUser, sampleChannel); /* user to channel */
  1272.             test (me, sampleChannel);         /* me to channel */
  1273.             display(MSG_TEST_TOPIC, "TOPIC", sampleUser, sampleChannel);
  1274.             display(MSG_TEST_JOIN, "JOIN", sampleUser, sampleChannel);
  1275.             display(MSG_TEST_PART, "PART", sampleUser, sampleChannel);
  1276.             display(MSG_TEST_KICK, "KICK", sampleUser, sampleChannel);
  1277.             display(MSG_TEST_QUIT, "QUIT", sampleUser, sampleChannel);
  1278.             display(getMsg(MSG_TEST_STALK, me.unicodeName),
  1279.                     "PRIVMSG", sampleUser, sampleChannel);
  1280.             display(MSG_TEST_STYLES, "PRIVMSG", me, sampleChannel);
  1281.         }
  1282.     }
  1283. }
  1284.  
  1285. function cmdNetwork(e)
  1286. {
  1287.     if (!(e.networkName in client.networks))
  1288.     {
  1289.         display (getMsg(MSG_ERR_UNKNOWN_NETWORK, e.networkName), MT_ERROR);
  1290.         return;
  1291.     }
  1292.  
  1293.     var network = client.networks[e.networkName];
  1294.  
  1295.     if (!("messages" in network))
  1296.         network.displayHere(getMsg(MSG_NETWORK_OPENED, network.name));
  1297.  
  1298.     dispatch("set-current-view", { view: network });
  1299. }
  1300.  
  1301. function cmdNetworks(e)
  1302. {
  1303.     const ns = "http://www.w3.org/1999/xhtml";
  1304.  
  1305.     var span = document.createElementNS(ns, "html:span");
  1306.  
  1307.     span.appendChild(newInlineText(MSG_NETWORKS_HEADA));
  1308.  
  1309.     var netnames = keys(client.networks).sort();
  1310.     var lastname = netnames[netnames.length - 1];
  1311.  
  1312.     for (n in netnames)
  1313.     {
  1314.         var net = client.networks[netnames[n]];
  1315.         var a = document.createElementNS(ns, "html:a");
  1316.         /* Test for an all-SSL network */
  1317.         var isSecure = true;
  1318.         for (var s in client.networks[netnames[n]].serverList)
  1319.         {
  1320.             if (!client.networks[netnames[n]].serverList[s].isSecure)
  1321.             {
  1322.                 isSecure = false;
  1323.                 break;
  1324.             }
  1325.         }
  1326.         a.setAttribute("class", "chatzilla-link");
  1327.         a.setAttribute("href", (isSecure ? "ircs://" : "irc://") + net.canonicalName);
  1328.         var t = newInlineText(net.unicodeName);
  1329.         a.appendChild(t);
  1330.         span.appendChild(a);
  1331.         if (netnames[n] != lastname)
  1332.             span.appendChild(newInlineText (MSG_COMMASP));
  1333.     }
  1334.  
  1335.     span.appendChild(newInlineText(MSG_NETWORKS_HEADB));
  1336.  
  1337.     display(span, MT_INFO);
  1338. }
  1339.  
  1340. function cmdServer(e)
  1341. {
  1342.     var ary = e.hostname.match(/^(.*):(\d+)$/);
  1343.     if (ary)
  1344.     {
  1345.         // Foolish user obviously hasn't read the instructions, but we're nice.
  1346.         e.password = e.port;
  1347.         e.port = ary[2];
  1348.         e.hostname = ary[1];
  1349.     }
  1350.  
  1351.     var name = e.hostname.toLowerCase();
  1352.  
  1353.     if (!e.port)
  1354.         e.port = 6667;
  1355.     else if (e.port != 6667)
  1356.         name += ":" + e.port;
  1357.  
  1358.     if (!(name in client.networks))
  1359.     {
  1360.         /* if there wasn't already a network created for this server,
  1361.          * make one. */
  1362.         client.addNetwork(name, [{name: e.hostname, port: e.port,
  1363.                                         password: e.password}], true);
  1364.     }
  1365.     else
  1366.     {
  1367.         // We are trying to connect without SSL, adjust for temporary networks
  1368.         if (client.networks[name].temporary)
  1369.             client.networks[name].serverList[0].isSecure = false;
  1370.         // update password on existing server.
  1371.         if (e.password)
  1372.             client.networks[name].serverList[0].password = e.password;
  1373.     }
  1374.  
  1375.     return client.connectToNetwork(name, false);
  1376. }
  1377.  
  1378. function cmdSSLServer(e)
  1379. {
  1380.     var ary = e.hostname.match(/^(.*):(\d+)$/);
  1381.     if (ary)
  1382.     {
  1383.         // Foolish user obviously hasn't read the instructions, but we're nice.
  1384.         e.password = e.port;
  1385.         e.port = ary[2];
  1386.         e.hostname = ary[1];
  1387.     }
  1388.  
  1389.     var name = e.hostname.toLowerCase();
  1390.  
  1391.     if (!e.port)
  1392.         e.port = 9999;
  1393.     if (e.port != 6667)
  1394.         name += ":" + e.port;
  1395.  
  1396.     if (!(name in client.networks))
  1397.     {
  1398.         /* if there wasn't already a network created for this server,
  1399.          * make one. */
  1400.         client.addNetwork(name, [{name: e.hostname, port: e.port,
  1401.                                   password: e.password, isSecure: true}], true);
  1402.     }
  1403.     else
  1404.     {
  1405.         // We are trying to connect using SSL, adjust for temporary networks
  1406.         if (client.networks[name].temporary)
  1407.             client.networks[name].serverList[0].isSecure = true;
  1408.         // update password on existing server.
  1409.         if (e.password)
  1410.             client.networks[name].serverList[0].password = e.password;
  1411.     }
  1412.  
  1413.     return client.connectToNetwork(name, true);
  1414. }
  1415.  
  1416.  
  1417. function cmdQuit(e)
  1418. {
  1419.     if (!e.reason)
  1420.         e.reason = client.userAgent;
  1421.  
  1422.     client.quit(e.reason);
  1423.     window.close();
  1424. }
  1425.  
  1426. function cmdQuitMozilla(e)
  1427. {
  1428.     client.quit(e.reason);
  1429.     goQuitApplication();
  1430. }
  1431.  
  1432. function cmdDisconnect(e)
  1433. {
  1434.     if (typeof e.reason != "string")
  1435.         e.reason = client.userAgent;
  1436.  
  1437.     e.network.quit(e.reason);
  1438. }
  1439.  
  1440. function cmdDisconnectAll(e)
  1441. {
  1442.     if (confirmEx(MSG_CONFIRM_DISCONNECT_ALL, ["!yes", "!no"]) != 0)
  1443.         return;
  1444.  
  1445.     var conNetworks = client.getConnectedNetworks();
  1446.     if (conNetworks.length <= 0)
  1447.     {
  1448.         display(MSG_NO_CONNECTED_NETS, MT_ERROR);
  1449.         return;
  1450.     }
  1451.  
  1452.     if (typeof e.reason != "string")
  1453.         e.reason = client.userAgent;
  1454.  
  1455.     for (var i = 0; i < conNetworks.length; i++)
  1456.         conNetworks[i].quit(e.reason);
  1457. }
  1458.  
  1459. function cmdDeleteView(e)
  1460. {
  1461.     if (!e.view)
  1462.         e.view = e.sourceObject;
  1463.  
  1464.     if (e.view.TYPE == "IRCChannel" && e.view.active)
  1465.         e.view.part();
  1466.     if (e.view.TYPE == "IRCDCCChat" && e.view.active)
  1467.         e.view.disconnect();
  1468.  
  1469.     if (client.viewsArray.length < 2)
  1470.     {
  1471.         display(MSG_ERR_LAST_VIEW, MT_ERROR);
  1472.         return;
  1473.     }
  1474.  
  1475.     var tb = getTabForObject(e.view);
  1476.     if (tb)
  1477.     {
  1478.         var i = deleteTab (tb);
  1479.         if (i != -1)
  1480.         {
  1481.             if (e.view.logFile)
  1482.             {
  1483.                 e.view.logFile.close();
  1484.                 e.view.logFile = null;
  1485.             }
  1486.             delete e.view.messageCount;
  1487.             delete e.view.messages;
  1488.             client.deck.removeChild(e.view.frame);
  1489.             delete e.view.frame;
  1490.  
  1491.             var oldView = client.currentObject;
  1492.             if (client.currentObject == e.view)
  1493.             {
  1494.                 if (i >= client.viewsArray.length)
  1495.                     i = client.viewsArray.length - 1;
  1496.                 oldView = client.viewsArray[i].source
  1497.             }
  1498.             client.currentObject = null;
  1499.             oldView.dispatch("set-current-view", { view: oldView });
  1500.         }
  1501.     }
  1502. }
  1503.  
  1504. function cmdHideView(e)
  1505. {
  1506.     if (!e.view)
  1507.         e.view = e.sourceObject;
  1508.  
  1509.     if (client.viewsArray.length < 2)
  1510.     {
  1511.         display(MSG_ERR_LAST_VIEW_HIDE, MT_ERROR);
  1512.         return;
  1513.     }
  1514.  
  1515.     var tb = getTabForObject(e.view);
  1516.  
  1517.     if (tb)
  1518.     {
  1519.         var i = deleteTab (tb);
  1520.         if (i != -1)
  1521.         {
  1522.             client.deck.removeChild(e.view.frame);
  1523.             delete e.view.frame;
  1524.  
  1525.             var oldView = client.currentObject;
  1526.             if (client.currentObject == e.view)
  1527.             {
  1528.                 if (i >= client.viewsArray.length)
  1529.                     i = client.viewsArray.length - 1;
  1530.                 oldView = client.viewsArray[i].source
  1531.             }
  1532.             client.currentObject = null;
  1533.             oldView.dispatch("set-current-view", { view: oldView });
  1534.         }
  1535.     }
  1536. }
  1537.  
  1538. function cmdClearView(e)
  1539. {
  1540.     if (!e.view)
  1541.         e.view = e.sourceObject;
  1542.  
  1543.     e.view.messages = null;
  1544.     e.view.messageCount = 0;
  1545.  
  1546.     e.view.displayHere(MSG_MESSAGES_CLEARED);
  1547.  
  1548.     syncOutputFrame(e.view);
  1549. }
  1550.  
  1551. function cmdNames(e)
  1552. {
  1553.     if (e.channelName)
  1554.     {
  1555.         e.channel = new CIRCChannel(e.server, e.channelName);
  1556.     }
  1557.     else
  1558.     {
  1559.         if (!e.channel)
  1560.         {
  1561.             display(getMsg(MSG_ERR_REQUIRED_PARAM, "channel-name"), MT_ERROR);
  1562.             return;
  1563.         }
  1564.     }
  1565.  
  1566.     e.channel.pendingNamesReply = true;
  1567.     e.server.sendData("NAMES " + e.channel.encodedName + "\n");
  1568. }
  1569.  
  1570. function cmdReconnect(e)
  1571. {
  1572.     if (e.network.isConnected())
  1573.     {
  1574.         // Set reconnect flag
  1575.         e.network.reconnect = true;
  1576.         if (typeof e.reason != "string")
  1577.             e.reason = MSG_RECONNECTING;
  1578.         // Now we disconnect.
  1579.         e.network.quit(e.reason);
  1580.     }
  1581.     else
  1582.     {
  1583.         e.network.connect(e.network.requireSecurity);
  1584.     }
  1585. }
  1586.  
  1587. function cmdReconnectAll(e)
  1588. {
  1589.     var reconnected = false;
  1590.     for (var net in client.networks)
  1591.     {
  1592.         if (client.networks[net].isConnected() ||
  1593.             ("messages" in client.networks[net]))
  1594.         {
  1595.             client.networks[net].dispatch("reconnect", { reason: e.reason });
  1596.             reconnected = true;
  1597.         }
  1598.     }
  1599.     if (!reconnected)
  1600.         display(MSG_NO_RECONNECTABLE_NETS, MT_ERROR);
  1601. }
  1602.  
  1603. function cmdRejoin(e)
  1604. {
  1605.     if (e.channel.joined)
  1606.     {
  1607.         if (!e.reason)
  1608.             e.reason = "";
  1609.         e.channel.dispatch("part", { reason: e.reason, noDelete: true });
  1610.     }
  1611.  
  1612.     e.channel.join(e.channel.mode.key);
  1613. }
  1614.  
  1615. function cmdTogglePref (e)
  1616. {
  1617.     var state = !client.prefs[e.prefName];
  1618.     client.prefs[e.prefName] = state;
  1619.     feedback(e, getMsg (MSG_FMT_PREF,
  1620.                         [e.prefName, state ? MSG_VAL_ON : MSG_VAL_OFF]));
  1621. }
  1622.  
  1623. function cmdToggleUI(e)
  1624. {
  1625.     var ids = new Array();
  1626.  
  1627.     switch (e.thing)
  1628.     {
  1629.         case "tabstrip":
  1630.             ids = ["view-tabs"];
  1631.             break;
  1632.  
  1633.         case "userlist":
  1634.             ids = ["main-splitter", "user-list-box"];
  1635.             break;
  1636.  
  1637.         case "header":
  1638.             client.currentObject.prefs["displayHeader"] =
  1639.                 !client.currentObject.prefs["displayHeader"];
  1640.             return;
  1641.  
  1642.         case "status":
  1643.             ids = ["status-bar"];
  1644.             break;
  1645.  
  1646.         default:
  1647.             ASSERT (0,"Unknown element ``" + e.thing +
  1648.                     "'' passed to onToggleVisibility.");
  1649.             return;
  1650.     }
  1651.  
  1652.     var newState;
  1653.     var elem = document.getElementById(ids[0]);
  1654.     var sourceObject = e.sourceObject;
  1655.  
  1656.     if (elem.getAttribute("collapsed") == "true")
  1657.     {
  1658.         if (e.thing == "userlist")
  1659.         {
  1660.             if (sourceObject.TYPE == "IRCChannel")
  1661.             {
  1662.                 client.rdf.setTreeRoot("user-list",
  1663.                                        sourceObject.getGraphResource());
  1664.             }
  1665.             else
  1666.             {
  1667.                 client.rdf.setTreeRoot("user-list", client.rdf.resNullChan);
  1668.             }
  1669.         }
  1670.  
  1671.         newState = "false";
  1672.     }
  1673.     else
  1674.     {
  1675.         newState = "true";
  1676.     }
  1677.  
  1678.     for (var i in ids)
  1679.     {
  1680.         elem = document.getElementById(ids[i]);
  1681.         elem.setAttribute ("collapsed", newState);
  1682.     }
  1683.  
  1684.     updateTitle();
  1685.     dispatch("focus-input");
  1686. }
  1687.  
  1688. function cmdCommands(e)
  1689. {
  1690.     display(MSG_COMMANDS_HEADER);
  1691.  
  1692.     var matchResult = client.commandManager.listNames(e.pattern, CMD_CONSOLE);
  1693.     matchResult = matchResult.join(MSG_COMMASP);
  1694.  
  1695.     if (e.pattern)
  1696.         display(getMsg(MSG_MATCHING_COMMANDS, [e.pattern, matchResult]));
  1697.     else
  1698.         display(getMsg(MSG_ALL_COMMANDS, matchResult));
  1699. }
  1700.  
  1701. function cmdAttach(e)
  1702. {
  1703.     if (e.ircUrl.search(/ircs?:\/\//i) != 0)
  1704.         e.ircUrl = "irc://" + e.ircUrl;
  1705.  
  1706.     var parsedURL = parseIRCURL(e.ircUrl);
  1707.     if (!parsedURL)
  1708.     {
  1709.         display(getMsg(MSG_ERR_BAD_IRCURL, e.ircUrl), MT_ERROR);
  1710.         return;
  1711.     }
  1712.  
  1713.     gotoIRCURL(e.ircUrl);
  1714. }
  1715.  
  1716. function cmdMe(e)
  1717. {
  1718.     if (!("act" in e.sourceObject))
  1719.     {
  1720.         display(getMsg(MSG_ERR_IMPROPER_VIEW, "me"), MT_ERROR);
  1721.         return;
  1722.     }
  1723.  
  1724.     var msg = filterOutput(e.action, "ACTION", "ME!");
  1725.     e.sourceObject.display(msg, "ACTION", "ME!", e.sourceObject);
  1726.     e.sourceObject.act(msg);
  1727. }
  1728.  
  1729. function cmdDescribe(e)
  1730. {
  1731.     var target = e.server.addTarget(e.target);
  1732.  
  1733.     var msg = filterOutput(e.action, "ACTION", "ME!");
  1734.     e.sourceObject.display(msg, "ACTION", "ME!", target);
  1735.     target.act(msg);
  1736. }
  1737.  
  1738. function cmdMotif(e)
  1739. {
  1740.     var pm;
  1741.     var msg;
  1742.  
  1743.     if (e.command.name == "channel-motif")
  1744.     {
  1745.         pm = e.channel.prefManager;
  1746.         msg = MSG_CURRENT_CSS_CHAN;
  1747.     }
  1748.     else if (e.command.name == "network-motif")
  1749.     {
  1750.         pm = e.network.prefManager;
  1751.         msg = MSG_CURRENT_CSS_NET;
  1752.     }
  1753.     else if (e.command.name == "user-motif")
  1754.     {
  1755.         pm = e.user.prefManager;
  1756.         msg = MSG_CURRENT_CSS_USER;
  1757.     }
  1758.     else
  1759.     {
  1760.         pm = client.prefManager;
  1761.         msg = MSG_CURRENT_CSS;
  1762.     }
  1763.  
  1764.     if (e.motif)
  1765.     {
  1766.         if (e.motif == "-")
  1767.         {
  1768.             // delete local motif in favor of default
  1769.             pm.clearPref("motif.current");
  1770.             e.motif = pm.prefs["motif.current"];
  1771.         }
  1772.         else if (e.motif.search(/\.css$/i) != -1)
  1773.         {
  1774.             // specific css file
  1775.             pm.prefs["motif.current"] = e.motif;
  1776.         }
  1777.         else
  1778.         {
  1779.             // motif alias
  1780.             var prefName = "motif." + e.motif;
  1781.             if (client.prefManager.isKnownPref(prefName))
  1782.             {
  1783.                 e.motif = client.prefManager.prefs[prefName];
  1784.             }
  1785.             else
  1786.             {
  1787.                 display(getMsg(MSG_ERR_UNKNOWN_MOTIF, e.motif), MT_ERROR);
  1788.                 return;
  1789.             }
  1790.  
  1791.             pm.prefs["motif.current"] = e.motif;
  1792.         }
  1793.  
  1794.     }
  1795.  
  1796.     display (getMsg(msg, pm.prefs["motif.current"]));
  1797. }
  1798.  
  1799. function cmdList(e)
  1800. {
  1801.     if (!e.channelName)
  1802.         e.channelName = "";
  1803.     e.network.list(e.channelName);
  1804. }
  1805.  
  1806. function cmdListPlugins(e)
  1807. {
  1808.     function listPlugin(plugin, i)
  1809.     {
  1810.         var enabled;
  1811.         if ((plugin.API > 0) || ("disablePlugin" in plugin.scope))
  1812.             enabled = plugin.enabled;
  1813.         else
  1814.             enabled = MSG_ALWAYS;
  1815.  
  1816.         display(getMsg(MSG_FMT_PLUGIN1, [i, plugin.url]));
  1817.         display(getMsg(MSG_FMT_PLUGIN2,
  1818.                        [plugin.id, plugin.version, enabled, plugin.status]));
  1819.         display(getMsg(MSG_FMT_PLUGIN3, plugin.description));
  1820.     }
  1821.  
  1822.     if (e.plugin)
  1823.     {
  1824.         listPlugin(e.plugin, 0);
  1825.         return;
  1826.     }
  1827.  
  1828.     if (client.plugins.length > 0)
  1829.     {
  1830.         for (var i = 0; i < client.plugins.length; ++i)
  1831.             listPlugin(client.plugins[i], i);
  1832.     }
  1833.     else
  1834.     {
  1835.         display(MSG_NO_PLUGINS);
  1836.     }
  1837. }
  1838.  
  1839. function cmdRlist(e)
  1840. {
  1841.     e.network.list(new RegExp(e.regexp, "i"));
  1842. }
  1843.  
  1844. function cmdReloadUI(e)
  1845. {
  1846.     if (!("getConnectionCount" in client) ||
  1847.         client.getConnectionCount() == 0)
  1848.     {
  1849.         window.location.href = window.location.href;
  1850.     }
  1851. }
  1852.  
  1853. function cmdQuery(e)
  1854. {
  1855.     // We'd rather *not* trigger the user.start event this time.
  1856.     blockEventSounds("user", "start");
  1857.     var user = openQueryTab(e.server, e.nickname);
  1858.     dispatch("set-current-view", { view: user });
  1859.  
  1860.     if (e.message)
  1861.     {
  1862.         e.message = filterOutput(e.message, "PRIVMSG", "ME!");
  1863.         user.display(e.message, "PRIVMSG", "ME!", user);
  1864.         user.say(e.message);
  1865.     }
  1866.  
  1867.     return user;
  1868. }
  1869.  
  1870. function cmdSay(e)
  1871. {
  1872.     if (!("say" in e.sourceObject))
  1873.     {
  1874.         display(getMsg(MSG_ERR_IMPROPER_VIEW, "say"), MT_ERROR);
  1875.         return;
  1876.     }
  1877.  
  1878.     var msg = filterOutput(e.message, "PRIVMSG", "ME!");
  1879.     e.sourceObject.display(msg, "PRIVMSG", "ME!", e.sourceObject);
  1880.     e.sourceObject.say(msg);
  1881. }
  1882.  
  1883. function cmdMsg(e)
  1884. {
  1885.     var target = e.server.addTarget(e.nickname);
  1886.  
  1887.     var msg = filterOutput(e.message, "PRIVMSG", "ME!");
  1888.     e.sourceObject.display(msg, "PRIVMSG", "ME!", target);
  1889.     target.say(msg);
  1890. }
  1891.  
  1892. function cmdNick(e)
  1893. {
  1894.     if (!e.nickname)
  1895.     {
  1896.         var curNick;
  1897.         if (e.network)
  1898.             curNick = e.network.prefs["nickname"];
  1899.         else
  1900.             curNick = client.prefs["nickname"];
  1901.  
  1902.         e.nickname = prompt(MSG_NICK_PROMPT, curNick);
  1903.         if (e.nickname == null)
  1904.             return;
  1905.     }
  1906.  
  1907.     if (e.server)
  1908.         e.server.changeNick(e.nickname);
  1909.  
  1910.     if (e.network)
  1911.         e.network.prefs["nickname"] = e.nickname;
  1912.     else
  1913.         client.prefs["nickname"] = e.nickname;
  1914. }
  1915.  
  1916. function cmdNotice(e)
  1917. {
  1918.     var target = e.server.addTarget(e.nickname);
  1919.  
  1920.     var msg = filterOutput(e.message, "NOTICE", "ME!");
  1921.     e.sourceObject.display(msg, "NOTICE", "ME!", target);
  1922.     target.notice(msg);
  1923. }
  1924.  
  1925. function cmdQuote(e)
  1926. {
  1927.     e.server.sendData(fromUnicode(e.ircCommand) + "\n", e.sourceObject);
  1928. }
  1929.  
  1930. function cmdEval(e)
  1931. {
  1932.     var sourceObject = e.sourceObject;
  1933.  
  1934.     try
  1935.     {
  1936.         sourceObject.doEval = function (__s) { return eval(__s); }
  1937.         sourceObject.display(e.expression, MT_EVALIN);
  1938.         var rv = String(sourceObject.doEval (e.expression));
  1939.         sourceObject.display (rv, MT_EVALOUT);
  1940.  
  1941.     }
  1942.     catch (ex)
  1943.     {
  1944.         sourceObject.display (String(ex), MT_ERROR);
  1945.     }
  1946. }
  1947.  
  1948. function cmdFocusInput(e)
  1949. {
  1950.     const WWATCHER_CTRID = "@mozilla.org/embedcomp/window-watcher;1";
  1951.     const nsIWindowWatcher = Components.interfaces.nsIWindowWatcher;
  1952.  
  1953.     var watcher =
  1954.         Components.classes[WWATCHER_CTRID].getService(nsIWindowWatcher);
  1955.     if (watcher.activeWindow == window)
  1956.         client.input.focus();
  1957.     else
  1958.         document.commandDispatcher.focusedElement = client.input;
  1959. }
  1960.  
  1961. function cmdGotoURL(e)
  1962. {
  1963.     const IO_SVC = "@mozilla.org/network/io-service;1";
  1964.     const EXT_PROTO_SVC = "@mozilla.org/uriloader/external-protocol-service;1";
  1965.  
  1966.     if (e.url.search(/^ircs?:/i) == 0)
  1967.     {
  1968.         gotoIRCURL(e.url);
  1969.         return;
  1970.     }
  1971.  
  1972.     if (e.url.search(/^x-cz-command:/i) == 0)
  1973.     {
  1974.         var ary = e.url.match(/^x-cz-command:(.*)$/i);
  1975.         e.sourceObject.frame.contentWindow.location.href = 
  1976.             "javascript:void(view.dispatch('" + decodeURI(ary[1]) + "'))";
  1977.         return;
  1978.     }
  1979.  
  1980.     if (e.command.name == "goto-url-external")
  1981.     {
  1982.         const ioSvc = getService(IO_SVC, "nsIIOService");
  1983.         const extProtoSvc = getService(EXT_PROTO_SVC,
  1984.                                        "nsIExternalProtocolService");
  1985.         var uri = ioSvc.newURI(e.url, "UTF-8", null);
  1986.         extProtoSvc.loadUrl(uri);
  1987.         return;
  1988.     }
  1989.  
  1990.     if (e.command.name == "goto-url-newwin")
  1991.     {
  1992.         openTopWin(e.url);
  1993.         dispatch("focus-input");
  1994.         return;
  1995.     }
  1996.  
  1997.     var window = getWindowByType("navigator:browser");
  1998.  
  1999.     if (!window)
  2000.     {
  2001.         openTopWin(e.url);
  2002.         dispatch("focus-input");
  2003.         return;
  2004.     }
  2005.  
  2006.     if (client.prefs["link.focus"])
  2007.         window.focus();
  2008.     if (e.command.name == "goto-url-newtab")
  2009.     {
  2010.         if (client.host == "Mozilla") {
  2011.             window.openNewTabWith(e.url, false, false);
  2012.         } else {
  2013.             window.openNewTabWith(e.url, null, null, null, null, false);
  2014.         }
  2015.         dispatch("focus-input");
  2016.         return;
  2017.     }
  2018.  
  2019.     var location = window.content.document.location;
  2020.     if (location.href.indexOf("chrome://chatzilla/content/") == 0)
  2021.     {
  2022.         // don't replace chatzilla running in a tab
  2023.         openTopWin(e.url);
  2024.         dispatch("focus-input");
  2025.         return;
  2026.     }
  2027.  
  2028.     location.href = e.url;
  2029.     dispatch("focus-input");
  2030. }
  2031.  
  2032. function cmdCTCP(e)
  2033. {
  2034.     var obj = e.server.addTarget(e.target);
  2035.     obj.ctcp(e.code, e.params);
  2036. }
  2037.  
  2038. function cmdJoin(e)
  2039. {
  2040.     /* Why are we messing with __proto__?
  2041.      *
  2042.      * Well, the short answer is so we can check the parameters passed to the
  2043.      * command properly.
  2044.      *
  2045.      * The long answer is that when a command is being dispatch, e.__proto__ is
  2046.      * set to the result of getObjectDetails() on the source view. This is for
  2047.      * a reason - it means that a parameter <channel-name> is automatically
  2048.      * filled in when run from a channel view, for example. However, here we
  2049.      * don't want just "a parameter" to satisfy some need, we actually want to
  2050.      * check the user's supplied parameters - clearing __proto__ allows this.
  2051.      * Naturally we put it back afterwards. (The upshot, and intended effect,
  2052.      * is that doing "/join" from a channel view will still open the dialog.)
  2053.      */
  2054.     var oldProto = e.__proto__;
  2055.     e.__proto__ = Object;
  2056.  
  2057.     if (!e.channelName)
  2058.     {
  2059.         window.openDialog("chrome://chatzilla/content/channels.xul", "",
  2060.                           "modal,resizable=yes", { client: client })
  2061.         return null;
  2062.     }
  2063.  
  2064.     e.__proto__ = oldProto;
  2065.  
  2066.     if (!("charset" in e))
  2067.     {
  2068.         e.charset = null;
  2069.     }
  2070.     else if (e.charset && !checkCharset(e.charset))
  2071.     {
  2072.         display (getMsg(MSG_ERR_INVALID_CHARSET, e.charset), MT_ERROR);
  2073.         return null;
  2074.     }
  2075.  
  2076.     if (e.channelName && (e.channelName.search(",") != -1))
  2077.     {
  2078.         // We can join multiple channels! Woo!
  2079.         var chan;
  2080.         var chans = e.channelName.split(",");
  2081.         var keys = [];
  2082.         if (e.key)
  2083.             keys = e.key.split(",");
  2084.         for (var c in chans)
  2085.         {
  2086.             chan = dispatch("join", { charset: e.charset,
  2087.                                       channelName: chans[c],
  2088.                                       key: keys.shift() });
  2089.         }
  2090.         return chan;
  2091.     }
  2092.     if (!e.channelName)
  2093.     {
  2094.         var channel = e.channel;
  2095.         if (!channel)
  2096.         {
  2097.             display(getMsg(MSG_ERR_REQUIRED_PARAM, "channel"), MT_ERROR);
  2098.             return null;
  2099.         }
  2100.  
  2101.         e.channelName = channel.unicodeName;
  2102.         if (channel.mode.key)
  2103.             e.key = channel.mode.key
  2104.     }
  2105.  
  2106.     if (arrayIndexOf(e.server.channelTypes, e.channelName[0]) == -1)
  2107.         e.channelName = e.server.channelTypes[0] + e.channelName;
  2108.  
  2109.     var charset = e.charset ? e.charset : e.network.prefs["charset"];
  2110.     e.channel = e.server.addChannel(e.channelName, charset);
  2111.     if (e.charset)
  2112.         e.channel.prefs["charset"] = e.charset;
  2113.  
  2114.     e.channel.join(e.key);
  2115.  
  2116.     /* !-channels are "safe" channels, and get a server-generated prefix. For
  2117.      * this reason, we shouldn't do anything client-side until the server
  2118.      * replies (since the reply will have the appropriate prefix). */
  2119.     if (e.channelName[0] != "!")
  2120.     {
  2121.         if (!("messages" in e.channel))
  2122.         {
  2123.             e.channel.displayHere(getMsg(MSG_CHANNEL_OPENED,
  2124.                                          e.channel.unicodeName), MT_INFO);
  2125.         }
  2126.  
  2127.         dispatch("set-current-view", { view: e.channel });
  2128.     }
  2129.  
  2130.     return e.channel;
  2131. }
  2132.  
  2133. function cmdLeave(e)
  2134. {
  2135.     if (!e.server)
  2136.     {
  2137.         display(MSG_ERR_IMPROPER_VIEW, MT_ERROR);
  2138.         return;
  2139.     }
  2140.  
  2141.     if (e.channelName)
  2142.     {
  2143.         if (arrayIndexOf(e.server.channelTypes, e.channelName[0]) == -1)
  2144.         {
  2145.             // No valid prefix character. Check they really meant a channel...
  2146.             var valid = false;
  2147.             for (var i = 0; i < e.server.channelTypes.length; i++)
  2148.             {
  2149.                 // Hmm, not ideal...
  2150.                 var chan = e.server.getChannel(e.server.channelTypes[i] +
  2151.                                                e.channelName);
  2152.                 if (chan)
  2153.                 {
  2154.                     // Yes! They just missed that single character.
  2155.                     e.channel = chan;
  2156.                     valid = true;
  2157.                     break;
  2158.                 }
  2159.             }
  2160.  
  2161.             // We can only let them get away here if we've got a channel.
  2162.             if (!valid)
  2163.             {
  2164.                 if (e.channel)
  2165.                 {
  2166.                     /* Their channel name was invalid, but we have a channel
  2167.                      * view, so we'll assume they did "/leave part msg".
  2168.                      */
  2169.                     e.reason = e.channelName + (e.reason ? " " + e.reason : "");
  2170.                 }
  2171.                 else
  2172.                 {
  2173.                     display(getMsg(MSG_ERR_UNKNOWN_CHANNEL, e.channelName),
  2174.                             MT_ERROR);
  2175.                     return;
  2176.                 }
  2177.             }
  2178.         }
  2179.         else
  2180.         {
  2181.             // Valid prefix, so get real channel (if it exists...).
  2182.             e.channel = e.server.getChannel(e.channelName);
  2183.             if (!e.channel)
  2184.             {
  2185.                 display(getMsg(MSG_ERR_UNKNOWN_CHANNEL, e.channelName),
  2186.                         MT_ERROR);
  2187.                 return;
  2188.             }
  2189.         }
  2190.     }
  2191.  
  2192.     /* If it's not active, we're not actually in it, even though the view is
  2193.      * still here.
  2194.      */
  2195.     if (e.channel.active)
  2196.     {
  2197.         if (e.noDelete)
  2198.             e.channel.noDelete = true;
  2199.  
  2200.         if (!e.reason)
  2201.             e.reason = "";
  2202.  
  2203.         e.server.sendData("PART " + e.channel.encodedName + " :" +
  2204.                           fromUnicode(e.reason, e.channel) + "\n");
  2205.     }
  2206.     else
  2207.     {
  2208.         if (!e.noDelete && client.prefs["deleteOnPart"])
  2209.             e.channel.dispatch("delete");
  2210.     }
  2211. }
  2212.  
  2213. function cmdReload(e)
  2214. {
  2215.     dispatch("load " + e.plugin.url);
  2216. }
  2217.  
  2218. function cmdLoad(e)
  2219. {
  2220.     var ex;
  2221.     var plugin;
  2222.  
  2223.     function removeOldPlugin(url)
  2224.     {
  2225.         var oldPlugin;
  2226.  
  2227.         var i = getPluginIndexByURL(url);
  2228.         if (i == -1)
  2229.             return -1;
  2230.  
  2231.         oldPlugin = client.plugins[i];
  2232.         if (oldPlugin.enabled)
  2233.         {
  2234.             if (oldPlugin.API > 0)
  2235.             {
  2236.                 if (!oldPlugin.disable())
  2237.                 {
  2238.                     display(getMsg(MSG_CANT_DISABLE, oldPlugin.id));
  2239.                     display (getMsg(MSG_ERR_SCRIPTLOAD, e.url));
  2240.                     return null;
  2241.                 }
  2242.                 client.prefManager.removeObserver(oldPlugin.prefManager);
  2243.                 oldPlugin.prefManager.destroy();
  2244.             }
  2245.             else if ("disablePlugin" in oldPlugin.scope)
  2246.             {
  2247.                 oldPlugin.scope.disablePlugin();
  2248.             }
  2249.             else
  2250.             {
  2251.                 display(getMsg(MSG_CANT_DISABLE, oldPlugin.id));
  2252.                 display (getMsg(MSG_ERR_SCRIPTLOAD, e.url));
  2253.                 return null;
  2254.             }
  2255.         }
  2256.  
  2257.         return i;
  2258.     }
  2259.  
  2260.     if (!e.scope)
  2261.         e.scope = new Object();
  2262.  
  2263.     if (!("plugin" in e.scope))
  2264.     {
  2265.         e.scope.plugin = { url: e.url, id: MSG_UNKNOWN, version: -1,
  2266.                            description: "", status: MSG_LOADING, enabled: false,
  2267.                            PluginAPI: 1, cwd: e.url.match(/^(.*?)[^\/]+$/)[1]};
  2268.  
  2269.     }
  2270.  
  2271.     plugin = e.scope.plugin;
  2272.     plugin.scope = e.scope;
  2273.  
  2274.     try
  2275.     {
  2276.         var rvStr;
  2277.         var rv = rvStr = client.load(e.url, e.scope);
  2278.         var index = removeOldPlugin(e.url);
  2279.  
  2280.         if (index == null)
  2281.             return null;
  2282.  
  2283.         if ("init" in plugin)
  2284.         {
  2285.             if (!("enable" in plugin) || !("disable" in plugin) ||
  2286.                 !("id" in plugin) || !(plugin.id.match(/^[A-Za-z-_]+$/)))
  2287.             {
  2288.                 display (getMsg(MSG_ERR_PLUGINAPI, e.url));
  2289.                 display (getMsg(MSG_ERR_SCRIPTLOAD, e.url));
  2290.                 return null;
  2291.             }
  2292.  
  2293.             plugin.API = 1;
  2294.             plugin.prefary = [["enabled", true, "hidden"]];
  2295.             rv = rvStr = plugin.init(e.scope);
  2296.  
  2297.             var branch = "extensions.irc.plugins." + plugin.id + ".";
  2298.             var prefManager = new PrefManager(branch, client.defaultBundle);
  2299.             prefManager.addPrefs(plugin.prefary);
  2300.             plugin.prefManager = prefManager;
  2301.             plugin.prefs = prefManager.prefs;
  2302.             if ("onPrefChanged" in plugin)
  2303.                 prefManager.addObserver(plugin);
  2304.             client.prefManager.addObserver(prefManager);
  2305.         }
  2306.         else
  2307.         {
  2308.             plugin.API = 0;
  2309.             if ("initPlugin" in e.scope)
  2310.                 rv = rvStr = e.scope.initPlugin(e.scope);
  2311.             plugin.enabled = true;
  2312.         }
  2313.         plugin.status = "loaded";
  2314.  
  2315.         if (typeof rv == "function")
  2316.             rvStr = "function";
  2317.  
  2318.         if (index != -1)
  2319.             client.plugins[index] = plugin;
  2320.         else
  2321.             index = client.plugins.push(plugin) - 1;
  2322.  
  2323.         feedback(e, getMsg(MSG_SUBSCRIPT_LOADED, [e.url, rvStr]), MT_INFO);
  2324.  
  2325.         if ((plugin.API > 0) && plugin.prefs["enabled"])
  2326.             dispatch("enable-plugin " + index);
  2327.         return rv;
  2328.     }
  2329.     catch (ex)
  2330.     {
  2331.         display (getMsg(MSG_ERR_SCRIPTLOAD, e.url));
  2332.         display (formatException(ex), MT_ERROR);
  2333.     }
  2334.  
  2335.     return null;
  2336. }
  2337.  
  2338. function cmdWho(e)
  2339. {
  2340.     e.network.pendingWhoReply = true;
  2341.     e.server.LIGHTWEIGHT_WHO = false;
  2342.     e.server.who(e.pattern);
  2343. }
  2344.  
  2345. function cmdWhoIs(e)
  2346. {
  2347.     for (var i = 0; i < e.nicknameList.length; i++)
  2348.     {
  2349.         if ((i < e.nicknameList.length - 1) &&
  2350.             (e.server.toLowerCase(e.nicknameList[i]) ==
  2351.              e.server.toLowerCase(e.nicknameList[i + 1])))
  2352.         {
  2353.             e.server.whois(e.nicknameList[i] + " " + e.nicknameList[i]);
  2354.             i++;
  2355.         }
  2356.         else
  2357.         {
  2358.             e.server.whois(e.nicknameList[i]);
  2359.         }
  2360.     }
  2361. }
  2362.  
  2363. function cmdWhoIsIdle(e)
  2364. {
  2365.     for (var i = 0; i < e.nicknameList.length; i++)
  2366.         e.server.whois(e.nicknameList[i] + " " + e.nicknameList[i]);
  2367. }
  2368.  
  2369. function cmdWhoWas(e)
  2370. {
  2371.     e.server.whowas(e.nickname, e.limit);
  2372. }
  2373.  
  2374. function cmdTopic(e)
  2375. {
  2376.     if (!e.newTopic)
  2377.         e.server.sendData("TOPIC " + e.channel.encodedName + "\n");
  2378.     else
  2379.         e.channel.setTopic(e.newTopic);
  2380. }
  2381.  
  2382. function cmdAbout(e)
  2383. {
  2384.     display(CIRCServer.prototype.VERSION_RPLY);
  2385.     display(MSG_HOMEPAGE);
  2386. }
  2387.  
  2388. function cmdAlias(e)
  2389. {
  2390.     var aliasDefs = client.prefs["aliases"];
  2391.     function getAlias(commandName)
  2392.     {
  2393.         for (var i = 0; i < aliasDefs.length; ++i)
  2394.         {
  2395.             var ary = aliasDefs[i].match(/^(.*?)\s*=\s*(.*)$/);
  2396.             if (ary[1] == commandName)
  2397.                 return [i, ary[2]];
  2398.         }
  2399.  
  2400.         return null;
  2401.     };
  2402.  
  2403.     var ary;
  2404.  
  2405.     if (e.commandList == "-")
  2406.     {
  2407.         /* remove alias */
  2408.         ary = getAlias(e.aliasName);
  2409.         if (!ary)
  2410.         {
  2411.             display(getMsg(MSG_NOT_AN_ALIAS, e.aliasName), MT_ERROR);
  2412.             return;
  2413.         }
  2414.  
  2415.         delete client.commandManager.commands[e.aliasName];
  2416.         arrayRemoveAt(aliasDefs, ary[0]);
  2417.         aliasDefs.update();
  2418.  
  2419.         feedback(e, getMsg(MSG_ALIAS_REMOVED, e.aliasName));
  2420.     }
  2421.     else if (e.aliasName)
  2422.     {
  2423.         /* add/change alias */
  2424.         client.commandManager.defineCommand(e.aliasName, e.commandList);
  2425.         ary = getAlias(e.aliasName);
  2426.         if (ary)
  2427.             aliasDefs[ary[0]] = e.aliasName + " = " + e.commandList;
  2428.         else
  2429.             aliasDefs.push(e.aliasName + " = " + e.commandList);
  2430.  
  2431.         aliasDefs.update();
  2432.  
  2433.         feedback(e, getMsg(MSG_ALIAS_CREATED, [e.aliasName, e.commandList]));
  2434.     }
  2435.     else
  2436.     {
  2437.         /* list aliases */
  2438.         if (aliasDefs.length == 0)
  2439.         {
  2440.             display(MSG_NO_ALIASES);
  2441.         }
  2442.         else
  2443.         {
  2444.             for (var i = 0; i < aliasDefs.length; ++i)
  2445.             {
  2446.                 ary = aliasDefs[i].match(/^(.*?)\s*=\s*(.*)$/);
  2447.                 if (ary)
  2448.                     display(getMsg(MSG_FMT_ALIAS, [ary[1], ary[2]]));
  2449.                 else
  2450.                     display(getMsg(MSG_ERR_BADALIAS, aliasDefs[i]));
  2451.             }
  2452.         }
  2453.     }
  2454. }
  2455.  
  2456. function cmdAway(e)
  2457. {
  2458.     function sendToAllNetworks(command, reason)
  2459.     {
  2460.         for (var n in client.networks)
  2461.         {
  2462.             if (client.networks[n].primServ &&
  2463.                 (client.networks[n].state == NET_ONLINE))
  2464.             {
  2465.                 client.networks[n].dispatch(command, { reason: reason });
  2466.             }
  2467.         }
  2468.     };
  2469.  
  2470.     if ((e.command.name == "away") || (e.command.name == "custom-away"))
  2471.     {
  2472.         /* going away */
  2473.         if (e.command.name == "custom-away")
  2474.         {
  2475.             e.reason = prompt(MSG_AWAY_PROMPT);
  2476.             // prompt() returns null for cancelling, a string otherwise (even if empty).
  2477.             if (e.reason == null)
  2478.                 return;
  2479.         }
  2480.         // No parameter, or user entered nothing in the prompt.
  2481.         if (!e.reason)
  2482.             e.reason = MSG_AWAY_DEFAULT;
  2483.  
  2484.         if (e.server)
  2485.         {
  2486.             if (e.network.state == NET_ONLINE)
  2487.             {
  2488.                 if (e.network.prefs["awayNick"])
  2489.                     e.server.sendData("NICK " + e.network.prefs["awayNick"] + "\n");
  2490.  
  2491.                 e.server.sendData("AWAY :" + fromUnicode(e.reason, e.network) + "\n");
  2492.             }
  2493.             e.network.prefs["away"] = e.reason;
  2494.         }
  2495.         else
  2496.         {
  2497.             // Client view, do command for all networks.
  2498.             sendToAllNetworks("away", e.reason);
  2499.             display(getMsg(MSG_AWAY_ON, e.reason));
  2500.         }
  2501.     }
  2502.     else
  2503.     {
  2504.         /* returning */
  2505.         if (e.server)
  2506.         {
  2507.             if (e.network.state == NET_ONLINE)
  2508.             {
  2509.                 if (e.network.prefs["awayNick"])
  2510.                     e.server.sendData("NICK " + e.network.prefs["nickname"] + "\n");
  2511.  
  2512.                 e.server.sendData("AWAY\n");
  2513.             }
  2514.             e.network.prefs["away"] = "";
  2515.         }
  2516.         else
  2517.         {
  2518.             // Client view, do command for all networks.
  2519.             sendToAllNetworks("back");
  2520.             display(MSG_AWAY_OFF);
  2521.         }
  2522.     }
  2523. }
  2524.  
  2525. function cmdOpenAtStartup(e)
  2526. {
  2527.     var url = e.sourceObject.getURL();
  2528.     var list = client.prefs["initialURLs"];
  2529.     var index = arrayIndexOf(list, url);
  2530.  
  2531.     if (e.toggle == null)
  2532.     {
  2533.         if (index == -1)
  2534.             display(getMsg(MSG_STARTUP_NOTFOUND, url));
  2535.         else
  2536.             display(getMsg(MSG_STARTUP_EXISTS, url));
  2537.         return;
  2538.     }
  2539.  
  2540.     e.toggle = getToggle(e.toggle, (index != -1));
  2541.  
  2542.     if (e.toggle)
  2543.     {
  2544.         // yes, please open at startup
  2545.         if (index == -1)
  2546.         {
  2547.             list.push(url);
  2548.             list.update();
  2549.             display(getMsg(MSG_STARTUP_ADDED, url));
  2550.         }
  2551.         else
  2552.         {
  2553.             display(getMsg(MSG_STARTUP_EXISTS, url));
  2554.         }
  2555.     }
  2556.     else
  2557.     {
  2558.         // no, please don't open at startup
  2559.         if (index != -1)
  2560.         {
  2561.             arrayRemoveAt(list, index);
  2562.             list.update();
  2563.             display(getMsg(MSG_STARTUP_REMOVED, url));
  2564.         }
  2565.         else
  2566.         {
  2567.             display(getMsg(MSG_STARTUP_NOTFOUND, url));
  2568.         }
  2569.     }
  2570. }
  2571.  
  2572. function cmdPass(e)
  2573. {
  2574.     /* Check we are connected, or at least pretending to be connected, so this
  2575.      * can actually send something.
  2576.      */
  2577.    if ((e.network.state != NET_ONLINE) && !e.server.isConnected)
  2578.    {
  2579.        feedback(e, MSG_ERR_NOT_CONNECTED);
  2580.        return;
  2581.    }
  2582.  
  2583.    e.server.sendData("PASS " + fromUnicode(e.password, e.server) + "\n");
  2584. }
  2585.  
  2586. function cmdPing (e)
  2587. {
  2588.     e.network.dispatch("ctcp", { target: e.target, code: "PING" });
  2589. }
  2590.  
  2591. function cmdPref (e)
  2592. {
  2593.     var msg;
  2594.     var pm;
  2595.  
  2596.     if (e.command.name == "network-pref")
  2597.     {
  2598.         pm = e.network.prefManager;
  2599.         msg = MSG_FMT_NETPREF;
  2600.     }
  2601.     else if (e.command.name == "channel-pref")
  2602.     {
  2603.         pm = e.channel.prefManager;
  2604.         msg = MSG_FMT_CHANPREF;
  2605.     }
  2606.     else if (e.command.name == "plugin-pref")
  2607.     {
  2608.         pm = e.plugin.prefManager;
  2609.         msg = MSG_FMT_PLUGINPREF;
  2610.     }
  2611.     else if (e.command.name == "user-pref")
  2612.     {
  2613.         pm = e.user.prefManager;
  2614.         msg = MSG_FMT_USERPREF;
  2615.     }
  2616.     else
  2617.     {
  2618.         pm = client.prefManager;
  2619.         msg = MSG_FMT_PREF;
  2620.     }
  2621.  
  2622.     var ary = pm.listPrefs(e.prefName);
  2623.     if (ary.length == 0)
  2624.     {
  2625.         display (getMsg(MSG_ERR_UNKNOWN_PREF, [e.prefName]),
  2626.                  MT_ERROR);
  2627.         return false;
  2628.     }
  2629.  
  2630.     if (e.prefValue == "-")
  2631.         e.deletePref = true;
  2632.  
  2633.     if (e.deletePref)
  2634.     {
  2635.         if (!(e.prefName in pm.prefRecords))
  2636.         {
  2637.             display(getMsg(MSG_ERR_UNKNOWN_PREF, [e.prefName]), MT_ERROR);
  2638.             return false;
  2639.         }
  2640.  
  2641.         try
  2642.         {
  2643.             pm.clearPref(e.prefName);
  2644.         }
  2645.         catch (ex)
  2646.         {
  2647.             // ignore exception generated by clear of nonexistant pref
  2648.             if (!("result" in ex) ||
  2649.                 ex.result != Components.results.NS_ERROR_UNEXPECTED)
  2650.             {
  2651.                 throw ex;
  2652.             }
  2653.         }
  2654.  
  2655.         var prefValue = pm.prefs[e.prefName];
  2656.         feedback (e, getMsg(msg, [e.prefName, pm.prefs[e.prefName]]));
  2657.         return true;
  2658.     }
  2659.  
  2660.     if (e.prefValue)
  2661.     {
  2662.         if (!(e.prefName in pm.prefRecords))
  2663.         {
  2664.             display(getMsg(MSG_ERR_UNKNOWN_PREF, [e.prefName]), MT_ERROR);
  2665.             return false;
  2666.         }
  2667.  
  2668.         var r = pm.prefRecords[e.prefName];
  2669.         var def, type;
  2670.  
  2671.         if (typeof r.defaultValue == "function")
  2672.             def = r.defaultValue(e.prefName);
  2673.         else
  2674.             def = r.defaultValue;
  2675.  
  2676.         type = typeof def;
  2677.  
  2678.         switch (type)
  2679.         {
  2680.             case "number":
  2681.                 e.prefValue = Number(e.prefValue);
  2682.                 break;
  2683.             case "boolean":
  2684.                 e.prefValue = (e.prefValue.toLowerCase() == "true");
  2685.                 break;
  2686.             case "string":
  2687.                 break;
  2688.             default:
  2689.                 if (isinstance(e.prefValue, Array))
  2690.                     e.prefValue = e.prefValue.join("; ");
  2691.                 if (isinstance(def, Array))
  2692.                     e.prefValue = pm.stringToArray(e.prefValue);
  2693.                 break;
  2694.         }
  2695.  
  2696.         pm.prefs[e.prefName] = e.prefValue;
  2697.         if (isinstance(e.prefValue, Array))
  2698.             e.prefValue = e.prefValue.join("; ");
  2699.         feedback (e, getMsg(msg, [e.prefName, e.prefValue]));
  2700.     }
  2701.     else
  2702.     {
  2703.         for (var i = 0; i < ary.length; ++i)
  2704.         {
  2705.             var value;
  2706.             if (isinstance(pm.prefs[ary[i]], Array))
  2707.                 value = pm.prefs[ary[i]].join("; ");
  2708.             else
  2709.                 value = pm.prefs[ary[i]];
  2710.  
  2711.             feedback(e, getMsg(msg, [ary[i], value]));
  2712.         }
  2713.     }
  2714.  
  2715.     return true;
  2716. }
  2717.  
  2718. function cmdPrint(e)
  2719. {
  2720.     if (("frame" in e.sourceObject) && e.sourceObject.frame &&
  2721.         ("contentWindow" in e.sourceObject.frame) &&
  2722.         e.sourceObject.frame.contentWindow)
  2723.     {
  2724.         e.sourceObject.frame.contentWindow.print();
  2725.     }
  2726.     else
  2727.     {
  2728.         display(MSG_ERR_UNABLE_TO_PRINT);
  2729.     }
  2730. }
  2731.  
  2732. function cmdVersion(e)
  2733. {
  2734.     e.network.dispatch("ctcp", { target: e.nickname, code: "VERSION"});
  2735. }
  2736.  
  2737. function cmdEcho(e)
  2738. {
  2739.     display(e.message);
  2740. }
  2741.  
  2742. function cmdInvite(e)
  2743. {
  2744.     var channel;
  2745.  
  2746.     if (!e.channelName)
  2747.     {
  2748.         channel = e.channel;
  2749.     }
  2750.     else
  2751.     {
  2752.         channel = e.server.getChannel(e.channelName);
  2753.         if (!channel)
  2754.         {
  2755.             display(getMsg(MSG_ERR_UNKNOWN_CHANNEL, e.channelName), MT_ERROR);
  2756.             return;
  2757.         }
  2758.     }
  2759.  
  2760.     channel.invite(e.nickname);
  2761. }
  2762.  
  2763. function cmdKick(e)
  2764. {
  2765.     if (!e.user)
  2766.         e.user = e.channel.getUser(e.nickname);
  2767.  
  2768.     if (!e.user)
  2769.     {
  2770.         display(getMsg(MSG_ERR_UNKNOWN_USER, e.nickname), MT_ERROR);
  2771.         return;
  2772.     }
  2773.  
  2774.     if (e.command.name == "kick-ban")
  2775.         e.sourceObject.dispatch("ban", { nickname: e.user.encodedName });
  2776.  
  2777.     e.user.kick(e.reason);
  2778. }
  2779.  
  2780. function cmdClient(e)
  2781. {
  2782.     dispatch("create-tab-for-view", { view: client });
  2783.  
  2784.     if (!client.messages)
  2785.     {
  2786.         client.display(MSG_CLIENT_OPENED);
  2787.         dispatch("set-current-view", { view: client });
  2788.         client.display(MSG_WELCOME, "HELLO");
  2789.         dispatch("networks");
  2790.         dispatch("commands");
  2791.     } else {
  2792.         dispatch("set-current-view", { view: client });
  2793.     }
  2794. }
  2795.  
  2796. function cmdNotify(e)
  2797. {
  2798.     var net = e.network;
  2799.  
  2800.     if (!e.nickname)
  2801.     {
  2802.         if (net.prefs["notifyList"].length > 0)
  2803.         {
  2804.             /* delete the lists and force a ISON check, this will
  2805.              * print the current online/offline status when the server
  2806.              * responds */
  2807.             delete net.onList;
  2808.             delete net.offList;
  2809.             onNotifyTimeout();
  2810.         }
  2811.         else
  2812.         {
  2813.             display(MSG_NO_NOTIFY_LIST);
  2814.         }
  2815.     }
  2816.     else
  2817.     {
  2818.         var adds = new Array();
  2819.         var subs = new Array();
  2820.  
  2821.         for (var i in e.nicknameList)
  2822.         {
  2823.             var nickname = e.server.toLowerCase(e.nicknameList[i]);
  2824.             var list = net.prefs["notifyList"];
  2825.             list = e.server.toLowerCase(list.join(";")).split(";");
  2826.             var idx = arrayIndexOf (list, nickname);
  2827.             if (idx == -1)
  2828.             {
  2829.                 net.prefs["notifyList"].push (nickname);
  2830.                 adds.push(nickname);
  2831.             }
  2832.             else
  2833.             {
  2834.                 arrayRemoveAt (net.prefs["notifyList"], idx);
  2835.                 subs.push(nickname);
  2836.             }
  2837.         }
  2838.         net.prefs["notifyList"].update();
  2839.  
  2840.         var msgname;
  2841.  
  2842.         if (adds.length > 0)
  2843.         {
  2844.             msgname = (adds.length == 1) ? MSG_NOTIFY_ADDONE :
  2845.                                            MSG_NOTIFY_ADDSOME;
  2846.             display(getMsg(msgname, arraySpeak(adds)));
  2847.         }
  2848.  
  2849.         if (subs.length > 0)
  2850.         {
  2851.             msgname = (subs.length == 1) ? MSG_NOTIFY_DELONE :
  2852.                                            MSG_NOTIFY_DELSOME;
  2853.             display(getMsg(msgname, arraySpeak(subs)));
  2854.         }
  2855.  
  2856.         delete net.onList;
  2857.         delete net.offList;
  2858.         onNotifyTimeout();
  2859.     }
  2860. }
  2861.  
  2862. function cmdStalk(e)
  2863. {
  2864.     var list = client.prefs["stalkWords"];
  2865.  
  2866.     if (!e.text)
  2867.     {
  2868.         if (list.length == 0)
  2869.             display(MSG_NO_STALK_LIST);
  2870.         else
  2871.         {
  2872.             function alphabetize(a, b)
  2873.             {
  2874.                 var A = a.toLowerCase();
  2875.                 var B = b.toLowerCase();
  2876.                 if (A < B) return -1;
  2877.                 if (B < A) return 1;
  2878.                 return 0;
  2879.             }
  2880.  
  2881.             list.sort(alphabetize);
  2882.             display(getMsg(MSG_STALK_LIST, list.join(MSG_COMMASP)));
  2883.         }
  2884.         return;
  2885.     }
  2886.  
  2887.     var notStalkingWord = true;
  2888.     var loweredText = e.text.toLowerCase();
  2889.  
  2890.     for (var i = 0; i < list.length; ++i)
  2891.         if (list[i].toLowerCase() == loweredText)
  2892.             notStalkingWord = false;
  2893.  
  2894.     if (notStalkingWord)
  2895.     {
  2896.         list.push(e.text);
  2897.         list.update();
  2898.         display(getMsg(MSG_STALK_ADD, e.text));
  2899.     }
  2900.     else
  2901.     {
  2902.         display(getMsg(MSG_STALKING_ALREADY, e.text));
  2903.     }
  2904. }
  2905.  
  2906. function cmdUnstalk(e)
  2907. {
  2908.     e.text = e.text.toLowerCase();
  2909.     var list = client.prefs["stalkWords"];
  2910.  
  2911.     for (var i = 0; i < list.length; ++i)
  2912.     {
  2913.         if (list[i].toLowerCase() == e.text)
  2914.         {
  2915.             list.splice(i, 1);
  2916.             list.update();
  2917.             display(getMsg(MSG_STALK_DEL, e.text));
  2918.             return;
  2919.         }
  2920.     }
  2921.  
  2922.     display(getMsg(MSG_ERR_UNKNOWN_STALK, e.text), MT_ERROR);
  2923. }
  2924.  
  2925. function cmdUsermode(e)
  2926. {
  2927.     if (e.newMode)
  2928.     {
  2929.         if (e.sourceObject.network)
  2930.             e.sourceObject.network.prefs["usermode"] = e.newMode;
  2931.         else
  2932.             client.prefs["usermode"] = e.newMode;
  2933.     }
  2934.     else
  2935.     {
  2936.         if (e.server && e.server.isConnected)
  2937.         {
  2938.             e.server.sendData("mode " + e.server.me.encodedName + "\n");
  2939.         }
  2940.         else
  2941.         {
  2942.             var prefs;
  2943.  
  2944.             if (e.network)
  2945.                 prefs = e.network.prefs;
  2946.             else
  2947.                 prefs = client.prefs;
  2948.  
  2949.             display(getMsg(MSG_USER_MODE,
  2950.                            [prefs["nickname"], prefs["usermode"]]),
  2951.                     MT_MODE);
  2952.         }
  2953.     }
  2954. }
  2955.  
  2956. function cmdLog(e)
  2957. {
  2958.     var view = e.sourceObject;
  2959.  
  2960.     if (e.state != null)
  2961.     {
  2962.         e.state = getToggle(e.state, view.prefs["log"])
  2963.         view.prefs["log"] = e.state;
  2964.     }
  2965.     else
  2966.     {
  2967.         if (view.prefs["log"])
  2968.             display(getMsg(MSG_LOGGING_ON, getLogPath(view)));
  2969.         else
  2970.             display(MSG_LOGGING_OFF);
  2971.     }
  2972. }
  2973.  
  2974. function cmdSave(e)
  2975. {
  2976.     var OutputProgressListener =
  2977.     {
  2978.         onStateChange: function(aWebProgress, aRequest, aStateFlags, aStatus)
  2979.         {
  2980.             // Use this to access onStateChange flags
  2981.             var requestSpec;
  2982.             try
  2983.             {
  2984.               var channel = aRequest.QueryInterface(nsIChannel);
  2985.               requestSpec = channel.URI.spec;
  2986.             }
  2987.             catch (ex) { }
  2988.  
  2989.             // Detect end of file saving of any file:
  2990.             if (aStateFlags & nsIWebProgressListener.STATE_STOP)
  2991.             {
  2992.                 if (aStatus == kErrorBindingAborted)
  2993.                     aStatus = 0;
  2994.  
  2995.                 // We abort saving for all errors except if image src file is
  2996.                 // not found
  2997.                 var abortSaving = (aStatus != 0 && aStatus != kFileNotFound);
  2998.                 if (abortSaving)
  2999.                 {
  3000.                     // Cancel saving
  3001.                     wbp.cancelSave();
  3002.                     display(getMsg(MSG_SAVE_ERR_FAILED, aMessage), MT_ERROR);
  3003.                     return;
  3004.                 }
  3005.  
  3006.                 if (aStateFlags & nsIWebProgressListener.STATE_IS_NETWORK
  3007.                     && wbp.currentState == nsIWBP.PERSIST_STATE_FINISHED)
  3008.                 {
  3009.                     // Let the user know:
  3010.                     pm = [e.sourceObject.viewName, e.filename];
  3011.                     display(getMsg(MSG_SAVE_SUCCESSFUL, pm), MT_INFO);
  3012.                 }
  3013.                 /* Check if we've finished. WebBrowserPersist screws up when we
  3014.                  * don't save additional files. Cope when saving html only or
  3015.                  * text.
  3016.                  */
  3017.                 else if (!requestSpec && saveType > 0)
  3018.                 {
  3019.                     pm = [e.sourceObject.viewName, e.filename];
  3020.                     display(getMsg(MSG_SAVE_SUCCESSFUL, pm), MT_INFO);
  3021.                 }
  3022.             }
  3023.         },
  3024.  
  3025.         onProgressChange: function(aWebProgress, aRequest, aCurSelfProgress,
  3026.                                   aMaxSelfProgress, aCurTotalProgress,
  3027.                                   aMaxTotalProgress) {},
  3028.         onLocationChange: function(aWebProgress, aRequest, aLocation) {},
  3029.         onStatusChange: function(aWebProgress, aRequest, aStatus, aMessage) {},
  3030.         onSecurityChange: function(aWebProgress, aRequest, state) {},
  3031.  
  3032.         QueryInterface: function(aIID)
  3033.         {
  3034.             if (aIID.equals(Components.interfaces.nsIWebProgressListener)
  3035.                 || aIID.equals(Components.interfaces.nsISupports)
  3036.                 || aIID.equals(Components.interfaces.nsISupportsWeakReference))
  3037.             {
  3038.                 return this;
  3039.             }
  3040.  
  3041.             throw Components.results.NS_NOINTERFACE;
  3042.         }
  3043.     };
  3044.  
  3045.     const kFileNotFound = 2152857618;
  3046.     const kErrorBindingAborted = 2152398850;
  3047.  
  3048.     const nsIWBP = Components.interfaces.nsIWebBrowserPersist;
  3049.     const nsIWebProgressListener = Components.interfaces.nsIWebProgressListener;
  3050.     const nsIChannel = Components.interfaces.nsIChannel;
  3051.  
  3052.     var wbp = newObject("@mozilla.org/embedding/browser/nsWebBrowserPersist;1",
  3053.                         nsIWBP);
  3054.     wbp.progressListener = OutputProgressListener;
  3055.  
  3056.     var file, saveType, saveFolder, docToBeSaved, title;
  3057.     var flags, fileType, charLimit;
  3058.     var dialogTitle, rv, pm;
  3059.  
  3060.     // We want proper descriptions and no "All Files" option.
  3061.     const TYPELIST = [[MSG_SAVE_COMPLETEVIEW,"*.htm;*.html"],
  3062.                       [MSG_SAVE_HTMLONLYVIEW,"*.htm;*.html"],
  3063.                       [MSG_SAVE_PLAINTEXTVIEW,"*.txt"], "$noAll"];
  3064.     // constants and variables for the wbp.saveDocument call
  3065.     var saveTypes =
  3066.     {
  3067.         complete: 0,
  3068.         htmlonly: 1,
  3069.         text: 2
  3070.     };
  3071.  
  3072.     if (!e.filename)
  3073.     {
  3074.         dialogTitle = getMsg(MSG_SAVE_DIALOGTITLE, e.sourceObject.viewName);
  3075.         rv = pickSaveAs(dialogTitle, TYPELIST, e.sourceObject.viewName +
  3076.                         ".html");
  3077.         if (rv.file == null)
  3078.             return;
  3079.         saveType = rv.picker.filterIndex;
  3080.         file = rv.file;
  3081.         e.filename = rv.file.path;
  3082.     }
  3083.     else
  3084.     {
  3085.         try
  3086.         {
  3087.             // Try to use this as a path
  3088.             file = nsLocalFile(e.filename);
  3089.         }
  3090.         catch (ex)
  3091.         {
  3092.             // try to use it as an url
  3093.             try
  3094.             {
  3095.                 file = getFileFromURLSpec(e.filename);
  3096.             }
  3097.             catch(ex)
  3098.             {
  3099.                 // What is the user thinking? It's not rocket science...
  3100.                 display(getMsg(MSG_SAVE_ERR_INVALID_PATH, e.filename),
  3101.                         MT_ERROR);
  3102.                 return;
  3103.             }
  3104.         }
  3105.  
  3106.         // Get extension and determine savetype
  3107.         if (!e.savetype)
  3108.         {
  3109.             var extension = file.path.substr(file.path.lastIndexOf("."));
  3110.             if (extension == ".txt")
  3111.             {
  3112.                 saveType = saveTypes["text"];
  3113.             }
  3114.             else if (extension.match(/\.x?html?$/))
  3115.             {
  3116.                 saveType = saveTypes["complete"];
  3117.             }
  3118.             else
  3119.             {
  3120.                 // No saveType and no decent extension --> out!
  3121.                 var errMsg;
  3122.                 if (extension.indexOf(".") < 0)
  3123.                     errMsg = MSG_SAVE_ERR_NO_EXT;
  3124.                 else
  3125.                     errMsg = getMsg(MSG_SAVE_ERR_INVALID_EXT, extension);
  3126.                 display(errMsg, MT_ERROR);
  3127.                 return;
  3128.             }
  3129.         }
  3130.         else
  3131.         {
  3132.             if (!(e.savetype in saveTypes))
  3133.             {
  3134.                 // no valid saveType
  3135.                 display(getMsg(MSG_SAVE_ERR_INVALID_SAVETYPE, e.savetype),
  3136.                             MT_ERROR);
  3137.                 return;
  3138.             }
  3139.             saveType = saveTypes[e.savetype];
  3140.         }
  3141.  
  3142.         var askforreplace = (e.isInteractive && file.exists());
  3143.         if (askforreplace && !confirm(getMsg(MSG_SAVE_FILEEXISTS, e.filename)))
  3144.             return;
  3145.     }
  3146.  
  3147.     // We don't want to convert anything, leave everything as is and replace
  3148.     // old files, as the user has been prompted about that already.
  3149.     wbp.persistFlags |= nsIWBP.PERSIST_FLAGS_NO_CONVERSION
  3150.                         | nsIWBP.PERSIST_FLAGS_REPLACE_EXISTING_FILES
  3151.                         | nsIWBP.PERSIST_FLAGS_NO_BASE_TAG_MODIFICATIONS
  3152.                         | nsIWBP.PERSIST_FLAGS_REPLACE_EXISTING_FILES
  3153.                         | nsIWBP.PERSIST_FLAGS_DONT_FIXUP_LINKS
  3154.                         | nsIWBP.PERSIST_FLAGS_DONT_CHANGE_FILENAMES;
  3155.  
  3156.     // Set the document from the current view, and set a usable title
  3157.     docToBeSaved = e.sourceObject.frame.contentDocument;
  3158.     var headElement = docToBeSaved.getElementsByTagName("HEAD")[0];
  3159.     var titleElements = docToBeSaved.getElementsByTagName("title");
  3160.     // Remove an existing title, there shouldn't be more than one.
  3161.     if (titleElements.length > 0)
  3162.         titleElements[0].parentNode.removeChild(titleElements[0]);
  3163.     title = docToBeSaved.createElement("title");
  3164.     title.appendChild(docToBeSaved.createTextNode(document.title +
  3165.                                                   " (" + new Date() + ")"));
  3166.     headElement.appendChild(title);
  3167.     // Set standard flags, file type, saveFolder and character limit
  3168.     flags = nsIWBP.ENCODE_FLAGS_ENCODE_BASIC_ENTITIES;
  3169.     fileType = "text/html";
  3170.     saveFolder = null;
  3171.     charLimit = 0;
  3172.  
  3173.     // Do saveType specific stuff
  3174.     switch (saveType)
  3175.     {
  3176.         case saveTypes["complete"]:
  3177.             // Get the directory into which to save associated files.
  3178.             saveFolder = file.clone();
  3179.             var baseName = saveFolder.leafName;
  3180.             baseName = baseName.substring(0, baseName.lastIndexOf("."));
  3181.             saveFolder.leafName = getMsg(MSG_SAVE_FILES_FOLDER, baseName);
  3182.             break;
  3183.             // html only does not need any additional configuration
  3184.         case saveTypes["text"]:
  3185.             // set flags for Plain Text
  3186.             flags = nsIWBP.ENCODE_FLAGS_FORMATTED;
  3187.             flags |= nsIWBP.ENCODE_FLAGS_ABSOLUTE_LINKS;
  3188.             flags |= nsIWBP.ENCODE_FLAGS_NOFRAMES_CONTENT;
  3189.             // set the file type and set character limit to 80
  3190.             fileType = "text/plain";
  3191.             charLimit = 80;
  3192.             break;
  3193.     }
  3194.  
  3195.     try
  3196.     {
  3197.         wbp.saveDocument(docToBeSaved, file, saveFolder, fileType, flags,
  3198.                          charLimit);
  3199.     }
  3200.     catch (ex)
  3201.     {
  3202.         pm = [e.sourceObject.viewName, e.filename, ex.message];
  3203.         display(getMsg(MSG_SAVE_ERR_FAILED, pm), MT_ERROR);
  3204.     }
  3205.     // Error handling and finishing message is done by the listener
  3206. }
  3207.  
  3208. function cmdSupports(e)
  3209. {
  3210.     var server = e.server;
  3211.     var data = server.supports;
  3212.  
  3213.     if ("channelTypes" in server)
  3214.         display(getMsg(MSG_SUPPORTS_CHANTYPES,
  3215.                        server.channelTypes.join(MSG_COMMASP)));
  3216.     if ("channelModes" in server)
  3217.     {
  3218.         display(getMsg(MSG_SUPPORTS_CHANMODESA,
  3219.                        server.channelModes.a.join(MSG_COMMASP)));
  3220.         display(getMsg(MSG_SUPPORTS_CHANMODESB,
  3221.                        server.channelModes.b.join(MSG_COMMASP)));
  3222.         display(getMsg(MSG_SUPPORTS_CHANMODESC,
  3223.                        server.channelModes.c.join(MSG_COMMASP)));
  3224.         display(getMsg(MSG_SUPPORTS_CHANMODESD,
  3225.                        server.channelModes.d.join(MSG_COMMASP)));
  3226.     }
  3227.  
  3228.     if ("userModes" in server)
  3229.     {
  3230.         var list = new Array();
  3231.         for (var m in server.userModes)
  3232.         {
  3233.             list.push(getMsg(MSG_SUPPORTS_USERMODE, [
  3234.                                                       server.userModes[m].mode,
  3235.                                                       server.userModes[m].symbol
  3236.                                                     ]));
  3237.         }
  3238.         display(getMsg(MSG_SUPPORTS_USERMODES, list.join(MSG_COMMASP)));
  3239.     }
  3240.  
  3241.     var listB1 = new Array();
  3242.     var listB2 = new Array();
  3243.     var listN = new Array();
  3244.     for (var k in data)
  3245.     {
  3246.         if (typeof data[k] == "boolean")
  3247.         {
  3248.             if (data[k])
  3249.                 listB1.push(k);
  3250.             else
  3251.                 listB2.push(k);
  3252.         }
  3253.         else
  3254.         {
  3255.             listN.push(getMsg(MSG_SUPPORTS_MISCOPTION, [ k, data[k] ] ));
  3256.         }
  3257.     }
  3258.     listB1.sort();
  3259.     listB2.sort();
  3260.     listN.sort();
  3261.     display(getMsg(MSG_SUPPORTS_FLAGSON, listB1.join(MSG_COMMASP)));
  3262.     display(getMsg(MSG_SUPPORTS_FLAGSOFF, listB2.join(MSG_COMMASP)));
  3263.     display(getMsg(MSG_SUPPORTS_MISCOPTIONS, listN.join(MSG_COMMASP)));
  3264. }
  3265.  
  3266. function cmdDoCommand(e)
  3267. {
  3268.     if (e.cmdName == "cmd_mozillaPrefs")
  3269.     {
  3270.         goPreferences('navigator',
  3271.                       'chrome://chatzilla/content/prefpanel/pref-irc.xul',
  3272.                       'navigator');
  3273.     }
  3274.     else if (e.cmdName == "cmd_chatzillaPrefs")
  3275.     {
  3276.         window.openDialog('chrome://chatzilla/content/config.xul', '',
  3277.                           'chrome,resizable,dialog=no', window);
  3278.     }
  3279.     else
  3280.     {
  3281.         doCommand(e.cmdName);
  3282.     }
  3283. }
  3284.  
  3285. function cmdTimestamps(e)
  3286. {
  3287.     var view = e.sourceObject;
  3288.  
  3289.     if (e.toggle != null)
  3290.     {
  3291.         e.toggle = getToggle(e.toggle, view.prefs["timestamps"])
  3292.         view.prefs["timestamps"] = e.toggle;
  3293.     }
  3294.     else
  3295.     {
  3296.         display(getMsg(MSG_FMT_PREF, ["timestamps",
  3297.                                       view.prefs["timestamps"]]));
  3298.     }
  3299. }
  3300.  
  3301. function cmdTimestampFormat(e)
  3302. {
  3303.     var view = e.sourceObject;
  3304.  
  3305.     if (e.format != null)
  3306.     {
  3307.         view.prefs["timestampFormat"] = e.format;
  3308.     }
  3309.     else
  3310.     {
  3311.         display(getMsg(MSG_FMT_PREF, ["timestampFormat",
  3312.                                       view.prefs["timestampFormat"]]));
  3313.     }
  3314. }
  3315.  
  3316. function cmdSetCurrentView(e)
  3317. {
  3318.     setCurrentObject(e.view);
  3319. }
  3320.  
  3321. function cmdIgnore(e)
  3322. {
  3323.     if (("mask" in e) && e.mask)
  3324.     {
  3325.         e.mask = e.server.toLowerCase(e.mask);
  3326.  
  3327.         if (e.command.name == "ignore")
  3328.         {
  3329.             if (e.network.ignore(e.mask))
  3330.                 display(getMsg(MSG_IGNORE_ADD, e.mask));
  3331.             else
  3332.                 display(getMsg(MSG_IGNORE_ADDERR, e.mask));
  3333.         }
  3334.         else
  3335.         {
  3336.             if (e.network.unignore(e.mask))
  3337.                 display(getMsg(MSG_IGNORE_DEL, e.mask));
  3338.             else
  3339.                 display(getMsg(MSG_IGNORE_DELERR, e.mask));
  3340.         }
  3341.     }
  3342.     else
  3343.     {
  3344.         var list = new Array();
  3345.         for (var m in e.network.ignoreList)
  3346.             list.push(m);
  3347.         if (list.length == 0)
  3348.             display(MSG_IGNORE_LIST_1);
  3349.         else
  3350.             display(getMsg(MSG_IGNORE_LIST_2, arraySpeak(list)));
  3351.     }
  3352. }
  3353.  
  3354. function cmdFont(e)
  3355. {
  3356.     var view = client;
  3357.     var pref, val, pVal;
  3358.  
  3359.     if (e.command.name == "font-family")
  3360.     {
  3361.         pref = "font.family";
  3362.         val = e.font;
  3363.  
  3364.         // Save new value, then display pref value.
  3365.         if (val)
  3366.             view.prefs[pref] = val;
  3367.  
  3368.         display(getMsg(MSG_FONTS_FAMILY_FMT, view.prefs[pref]));
  3369.     }
  3370.     else if (e.command.name == "font-size")
  3371.     {
  3372.         pref = "font.size";
  3373.         val = e.fontSize;
  3374.  
  3375.         // Ok, we've got an input.
  3376.         if (val)
  3377.         {
  3378.             // Get the current value, use user's default if needed.
  3379.             pVal = view.prefs[pref];
  3380.             if (pVal == 0)
  3381.                 pVal = getDefaultFontSize();
  3382.  
  3383.             // Handle user's input...
  3384.             switch(val) {
  3385.                 case "default":
  3386.                     val = 0;
  3387.                     break;
  3388.  
  3389.                 case "small":
  3390.                     val = getDefaultFontSize() - 2;
  3391.                     break;
  3392.  
  3393.                 case "medium":
  3394.                     val = getDefaultFontSize();
  3395.                     break;
  3396.  
  3397.                 case "large":
  3398.                     val = getDefaultFontSize() + 2;
  3399.                     break;
  3400.  
  3401.                 case "smaller":
  3402.                     val = pVal - 2;
  3403.                     break;
  3404.  
  3405.                 case "bigger":
  3406.                     val = pVal + 2;
  3407.                     break;
  3408.  
  3409.                 default:
  3410.                     val = Number(val);
  3411.             }
  3412.             // Save the new value.
  3413.             view.prefs[pref] = val;
  3414.         }
  3415.  
  3416.         // Show the user what the pref is set to.
  3417.         if (view.prefs[pref] == 0)
  3418.             display(MSG_FONTS_SIZE_DEFAULT);
  3419.         else
  3420.             display(getMsg(MSG_FONTS_SIZE_FMT, view.prefs[pref]));
  3421.     }
  3422.     else if (e.command.name == "font-family-other")
  3423.     {
  3424.         val = prompt(MSG_FONTS_FAMILY_PICK, view.prefs["font.family"]);
  3425.         if (!val)
  3426.             return;
  3427.  
  3428.         dispatch("font-family", { font: val });
  3429.     }
  3430.     else if (e.command.name == "font-size-other")
  3431.     {
  3432.         pVal = view.prefs["font.size"];
  3433.         if (pVal == 0)
  3434.             pVal = getDefaultFontSize();
  3435.  
  3436.         val = prompt(MSG_FONTS_SIZE_PICK, pVal);
  3437.         if (!val)
  3438.             return;
  3439.  
  3440.         dispatch("font-size", { fontSize: val });
  3441.     }
  3442. }
  3443.  
  3444. function cmdDCCChat(e)
  3445. {
  3446.     if (!jsenv.HAS_SERVER_SOCKETS)
  3447.         return display(MSG_DCC_NOT_POSSIBLE);
  3448.     if (!client.prefs["dcc.enabled"])
  3449.         return display(MSG_DCC_NOT_ENABLED);
  3450.  
  3451.     if (!e.nickname && !e.user)
  3452.         return display(MSG_DCC_ERR_NOUSER);
  3453.  
  3454.     var user;
  3455.     if (e.nickname)
  3456.         user = e.server.addUser(e.nickname);
  3457.     else
  3458.         user = e.server.addUser(e.user.unicodeName);
  3459.  
  3460.     var u = client.dcc.addUser(user);
  3461.     var c = client.dcc.addChat(u, client.dcc.getNextPort());
  3462.     c.request();
  3463.  
  3464.     client.munger.entries[".inline-buttons"].enabled = true;
  3465.     var cmd = getMsg(MSG_DCC_COMMAND_CANCEL, "dcc-close " + c.id);
  3466.     display(getMsg(MSG_DCCCHAT_SENT_REQUEST, [u.unicodeName, c.localIP,
  3467.                                               c.port, cmd]), "DCC-CHAT");
  3468.     client.munger.entries[".inline-buttons"].enabled = false;
  3469.  
  3470.     return true;
  3471. }
  3472.  
  3473. function cmdDCCClose(e)
  3474. {
  3475.     if (!jsenv.HAS_SERVER_SOCKETS)
  3476.         return display(MSG_DCC_NOT_POSSIBLE);
  3477.     if (!client.prefs["dcc.enabled"])
  3478.         return display(MSG_DCC_NOT_ENABLED);
  3479.  
  3480.     // If there is no nickname specified, use current view.
  3481.     if (!e.nickname)
  3482.     {
  3483.         if (client.currentObject.TYPE == "IRCDCCChat")
  3484.             return client.currentObject.abort();
  3485.         // ...if there is one.
  3486.         return display(MSG_DCC_ERR_NOCHAT);
  3487.     }
  3488.  
  3489.     var o = client.dcc.findByID(e.nickname);
  3490.     if (o)
  3491.         // Direct ID --> object request.
  3492.         return o.abort();
  3493.  
  3494.     if (e.type)
  3495.         e.type = [e.type.toLowerCase()];
  3496.     else
  3497.         e.type = ["chat", "file"];
  3498.  
  3499.     // Go ask the DCC code for some matching requets.
  3500.     var list = client.dcc.getMatches
  3501.               (e.nickname, e.file, e.type, [DCC_DIR_GETTING, DCC_DIR_SENDING],
  3502.                [DCC_STATE_REQUESTED, DCC_STATE_ACCEPTED, DCC_STATE_CONNECTED]);
  3503.  
  3504.     // Disconnect if only one match.
  3505.     if (list.length == 1)
  3506.         return list[0].abort();
  3507.  
  3508.     // Oops, couldn't figure the user's requets out, so give them some help.
  3509.     display(getMsg(MSG_DCC_ACCEPTED_MATCHES, [list.length]));
  3510.     display(MSG_DCC_MATCHES_HELP);
  3511.     return true;
  3512. }
  3513.  
  3514. function cmdDCCSend(e)
  3515. {
  3516.     if (!jsenv.HAS_SERVER_SOCKETS)
  3517.         return display(MSG_DCC_NOT_POSSIBLE);
  3518.     if (!client.prefs["dcc.enabled"])
  3519.         return display(MSG_DCC_NOT_ENABLED);
  3520.  
  3521.     const DIRSVC_CID = "@mozilla.org/file/directory_service;1";
  3522.     const nsIProperties = Components.interfaces.nsIProperties;
  3523.  
  3524.     if (!e.nickname && !e.user)
  3525.         return display(MSG_DCC_ERR_NOUSER);
  3526.  
  3527.     // Accept the request passed in...
  3528.     var file;
  3529.     if (!e.file)
  3530.     {
  3531.         var pickerRv = pickOpen(MSG_DCCFILE_SEND);
  3532.         if (pickerRv.reason == PICK_CANCEL)
  3533.             return false;
  3534.         file = pickerRv.file;
  3535.     }
  3536.     else
  3537.     {
  3538.         // Wrap in try/catch because nsILocalFile creation throws a freaking
  3539.         // error if it doesn't get a FULL path.
  3540.         try
  3541.         {
  3542.             file = nsLocalFile(e.file);
  3543.         }
  3544.         catch(ex)
  3545.         {
  3546.             // Ok, try user's home directory.
  3547.             var fl = Components.classes[DIRSVC_CID].getService(nsIProperties);
  3548.             file = fl.get("Home", Components.interfaces.nsILocalFile);
  3549.  
  3550.             // Another freaking try/catch wrapper.
  3551.             try
  3552.             {
  3553.                 // NOTE: This is so pathetic it can't cope with any path
  3554.                 // separators in it, so don't even THINK about lobing a
  3555.                 // relative path at it.
  3556.                 file.append(e.file);
  3557.  
  3558.                 // Wow. We survived.
  3559.             }
  3560.             catch (ex)
  3561.             {
  3562.                 return display(MSG_DCCFILE_ERR_NOTFOUND);
  3563.             }
  3564.         }
  3565.     }
  3566.     if (!file.exists())
  3567.         return display(MSG_DCCFILE_ERR_NOTFOUND);
  3568.     if (!file.isFile())
  3569.         return display(MSG_DCCFILE_ERR_NOTAFILE);
  3570.     if (!file.isReadable())
  3571.         return display(MSG_DCCFILE_ERR_NOTREADABLE);
  3572.  
  3573.     var user;
  3574.     if (e.nickname)
  3575.         user = e.server.addUser(e.nickname);
  3576.     else
  3577.         user = e.server.addUser(e.user.unicodeName);
  3578.  
  3579.     var u = client.dcc.addUser(user);
  3580.     var c = client.dcc.addFileTransfer(u, client.dcc.getNextPort());
  3581.     c.request(file);
  3582.  
  3583.     client.munger.entries[".inline-buttons"].enabled = true;
  3584.     var cmd = getMsg(MSG_DCC_COMMAND_CANCEL, "dcc-close " + c.id);
  3585.     display(getMsg(MSG_DCCFILE_SENT_REQUEST, [u.unicodeName, c.localIP, c.port,
  3586.                                               file.leafName, c.size, cmd]),
  3587.             "DCC-FILE");
  3588.     client.munger.entries[".inline-buttons"].enabled = false;
  3589.  
  3590.     return true;
  3591. }
  3592.  
  3593. function cmdDCCList(e) {
  3594.     if (!jsenv.HAS_SERVER_SOCKETS)
  3595.         return display(MSG_DCC_NOT_POSSIBLE);
  3596.     if (!client.prefs["dcc.enabled"])
  3597.         return display(MSG_DCC_NOT_ENABLED);
  3598.  
  3599.     var counts = { pending: 0, connected: 0, failed: 0 };
  3600.     var k;
  3601.  
  3602.     // Get all the DCC sessions.
  3603.     var list = client.dcc.getMatches();
  3604.  
  3605.     for (k = 0; k < list.length; k++) {
  3606.         var c = list[k];
  3607.         var type = c.TYPE.substr(6, c.TYPE.length - 6);
  3608.  
  3609.         var dir = MSG_UNKNOWN;
  3610.         var tf = MSG_UNKNOWN;
  3611.         if (c.state.dir == DCC_DIR_SENDING)
  3612.         {
  3613.             dir = MSG_DCCLIST_DIR_OUT;
  3614.             tf = MSG_DCCLIST_TO;
  3615.         }
  3616.         else if (c.state.dir == DCC_DIR_GETTING)
  3617.         {
  3618.             dir = MSG_DCCLIST_DIR_IN;
  3619.             tf = MSG_DCCLIST_FROM;
  3620.         }
  3621.  
  3622.         var state = MSG_UNKNOWN;
  3623.         var cmds = "";
  3624.         switch (c.state.state)
  3625.         {
  3626.             case DCC_STATE_REQUESTED:
  3627.                 state = MSG_DCC_STATE_REQUEST;
  3628.                 if (c.state.dir == DCC_DIR_GETTING)
  3629.                 {
  3630.                     cmds = getMsg(MSG_DCC_COMMAND_ACCEPT, "dcc-accept " + c.id) + " " +
  3631.                            getMsg(MSG_DCC_COMMAND_DECLINE, "dcc-decline " + c.id);
  3632.                 }
  3633.                 else
  3634.                 {
  3635.                     cmds = getMsg(MSG_DCC_COMMAND_CANCEL, "dcc-close " + c.id);
  3636.                 }
  3637.                 counts.pending++;
  3638.                 break;
  3639.             case DCC_STATE_ACCEPTED:
  3640.                 state = MSG_DCC_STATE_ACCEPT;
  3641.                 counts.connected++;
  3642.                 break;
  3643.             case DCC_STATE_DECLINED:
  3644.                 state = MSG_DCC_STATE_DECLINE;
  3645.                 break;
  3646.             case DCC_STATE_CONNECTED:
  3647.                 state = MSG_DCC_STATE_CONNECT;
  3648.                 cmds = getMsg(MSG_DCC_COMMAND_CLOSE, "dcc-close " + c.id);
  3649.                 if (c.TYPE == "IRCDCCFileTransfer")
  3650.                 {
  3651.                     state = getMsg(MSG_DCC_STATE_CONNECTPRO,
  3652.                                    [Math.floor(100 * c.position / c.size),
  3653.                                     c.position, c.size]);
  3654.                 }
  3655.                 counts.connected++;
  3656.                 break;
  3657.             case DCC_STATE_DONE:
  3658.                 state = MSG_DCC_STATE_DISCONNECT;
  3659.                 break;
  3660.             case DCC_STATE_ABORTED:
  3661.                 state = MSG_DCC_STATE_ABORT;
  3662.                 counts.failed++;
  3663.                 break;
  3664.             case DCC_STATE_FAILED:
  3665.                 state = MSG_DCC_STATE_FAIL;
  3666.                 counts.failed++;
  3667.                 break;
  3668.         }
  3669.         client.munger.entries[".inline-buttons"].enabled = true;
  3670.         display(getMsg(MSG_DCCLIST_LINE, [k + 1, state, dir, type, tf,
  3671.                                           c.unicodeName, c.remoteIP, c.port,
  3672.                                           cmds]));
  3673.         client.munger.entries[".inline-buttons"].enabled = false;
  3674.     }
  3675.     display(getMsg(MSG_DCCLIST_SUMMARY, [counts.pending, counts.connected,
  3676.                                          counts.failed]));
  3677.     return true;
  3678. }
  3679.  
  3680. function cmdDCCAccept(e)
  3681. {
  3682.     if (!jsenv.HAS_SERVER_SOCKETS)
  3683.         return display(MSG_DCC_NOT_POSSIBLE);
  3684.     if (!client.prefs["dcc.enabled"])
  3685.         return display(MSG_DCC_NOT_ENABLED);
  3686.  
  3687.     function accept(c)
  3688.     {
  3689.         if (c.TYPE == "IRCDCCChat")
  3690.             return c.accept();
  3691.  
  3692.         // Accept the request passed in...
  3693.         var filename = c.filename;
  3694.         var ext = "*";
  3695.         var m = filename.match(/...\.([a-z]+)$/i);
  3696.         if (m)
  3697.             ext = "*." + m[1];
  3698.  
  3699.         var pickerRv = pickSaveAs(getMsg(MSG_DCCFILE_SAVE_TO, filename),
  3700.                                   ["$all", ext], filename);
  3701.         if (pickerRv.reason == PICK_CANCEL)
  3702.             return false;
  3703.         c.accept(pickerRv.file);
  3704.  
  3705.         if (c.TYPE == "CIRCDCCChat")
  3706.             display(getMsg(MSG_DCCCHAT_ACCEPTED, [c.unicodeName, c.remoteIP,
  3707.                                                   c.port]),
  3708.                     "DCC-CHAT");
  3709.         else
  3710.             display(getMsg(MSG_DCCFILE_ACCEPTED, [c.filename, c.unicodeName,
  3711.                                                   c.remoteIP, c.port]),
  3712.                     "DCC-FILE");
  3713.         return true;
  3714.     };
  3715.  
  3716.     // If there is no nickname specified, use the "last" item.
  3717.     // This is the last DCC request that arrvied.
  3718.     if (!e.nickname && client.dcc.last)
  3719.     {
  3720.         if ((new Date() - client.dcc.lastTime) >= 10000)
  3721.             return accept(client.dcc.last);
  3722.         return display(MSG_DCC_ERR_ACCEPT_TIME);
  3723.     }
  3724.  
  3725.     var o = client.dcc.findByID(e.nickname);
  3726.     if (o)
  3727.         // Direct ID --> object request.
  3728.         return accept(o);
  3729.  
  3730.     if (e.type)
  3731.         e.type = [e.type.toLowerCase()];
  3732.     else
  3733.         e.type = ["chat", "file"];
  3734.  
  3735.     // Go ask the DCC code for some matching requets.
  3736.     var list = client.dcc.getMatches(e.nickname, e.file, e.type,
  3737.                                      [DCC_DIR_GETTING], [DCC_STATE_REQUESTED]);
  3738.     // Accept if only one match.
  3739.     if (list.length == 1)
  3740.         return accept(list[0]);
  3741.  
  3742.     // Oops, couldn't figure the user's requets out, so give them some help.
  3743.     display(getMsg(MSG_DCC_PENDING_MATCHES, [list.length]));
  3744.     display(MSG_DCC_MATCHES_HELP);
  3745.     return true;
  3746. }
  3747.  
  3748. function cmdDCCDecline(e)
  3749. {
  3750.     if (!jsenv.HAS_SERVER_SOCKETS)
  3751.         return display(MSG_DCC_NOT_POSSIBLE);
  3752.     if (!client.prefs["dcc.enabled"])
  3753.         return display(MSG_DCC_NOT_ENABLED);
  3754.  
  3755.     function decline(c)
  3756.     {
  3757.         // Decline the request passed in...
  3758.         c.decline();
  3759.         if (c.TYPE == "CIRCDCCChat")
  3760.             display(getMsg(MSG_DCCCHAT_DECLINED, c._getParams()), "DCC-CHAT");
  3761.         else
  3762.             display(getMsg(MSG_DCCFILE_DECLINED, c._getParams()), "DCC-FILE");
  3763.     };
  3764.  
  3765.     // If there is no nickname specified, use the "last" item.
  3766.     // This is the last DCC request that arrvied.
  3767.     if (!e.nickname && client.dcc.last)
  3768.         return decline(client.dcc.last);
  3769.  
  3770.     var o = client.dcc.findByID(e.nickname);
  3771.     if (o)
  3772.         // Direct ID --> object request.
  3773.         return decline(o);
  3774.  
  3775.     if (!e.type)
  3776.         e.type = ["chat", "file"];
  3777.  
  3778.     // Go ask the DCC code for some matching requets.
  3779.     var list = client.dcc.getMatches(e.nickname, e.file, e.type,
  3780.                                      [DCC_DIR_GETTING], [DCC_STATE_REQUESTED]);
  3781.     // Decline if only one match.
  3782.     if (list.length == 1)
  3783.         return decline(list[0]);
  3784.  
  3785.     // Oops, couldn't figure the user's requets out, so give them some help.
  3786.     display(getMsg(MSG_DCC_PENDING_MATCHES, [list.length]));
  3787.     display(MSG_DCC_MATCHES_HELP);
  3788.     return true;
  3789. }
  3790.  
  3791. function cmdTextDirection(e)
  3792. {
  3793.     var direction;
  3794.     var sourceObject = e.sourceObject.frame.contentDocument.body;
  3795.  
  3796.     switch (e.dir)
  3797.     {
  3798.         case "toggle":
  3799.             if (sourceObject.getAttribute("dir") == "rtl")
  3800.                 direction = 'ltr';
  3801.             else
  3802.                 direction = 'rtl';
  3803.             break;
  3804.         case "rtl":
  3805.             direction = 'rtl';
  3806.             break;
  3807.         default:
  3808.             // that is "case "ltr":",
  3809.             // but even if !e.dir OR e.dir is an invalid value -> set to
  3810.             // default direction
  3811.             direction = 'ltr';
  3812.     }
  3813.     client.input.setAttribute("dir", direction);
  3814.     sourceObject.setAttribute("dir", direction);
  3815.  
  3816.     return true;
  3817. }
  3818.  
  3819. function cmdInputTextDirection(e)
  3820. {
  3821.     var direction;
  3822.  
  3823.     switch (e.dir)
  3824.     {
  3825.         case "rtl":
  3826.             client.input.setAttribute("dir", "rtl");
  3827.             break
  3828.         default:
  3829.             // that is "case "ltr":", but even if !e.dir OR e.dir is an
  3830.             //invalid value -> set to default direction
  3831.             client.input.setAttribute("dir", "ltr");
  3832.     }
  3833.  
  3834.     return true;
  3835. }
  3836.  
  3837. function cmdFind(e)
  3838. {
  3839.     findInPage(getFindData(e));
  3840. }
  3841.  
  3842. function cmdFindAgain(e)
  3843. {
  3844.     if (canFindAgainInPage())
  3845.         findAgainInPage(getFindData(e));
  3846. }
  3847.  
  3848. function cmdURLs(e)
  3849. {
  3850.     if (client.prefs["urls.list"].length == 0)
  3851.     {
  3852.         display(MSG_URLS_NONE);
  3853.     }
  3854.     else
  3855.     {
  3856.         /* Store the current URL list, so we can put it back afterwards. This
  3857.          * is needed because the process of displaying the list changes the
  3858.          * list! (think about it for a second)
  3859.          */
  3860.         var oldList = client.prefs["urls.list"];
  3861.         client.prefs["urls.list"] = new Array();
  3862.  
  3863.         var num = e.number || client.prefs["urls.display"];
  3864.         if (num > oldList.length)
  3865.             num = oldList.length;
  3866.         display(getMsg(MSG_URLS_HEADER, num));
  3867.  
  3868.         for (var i = 0; i < num; i++)
  3869.             display(getMsg(MSG_URLS_ITEM, [i + 1, oldList[i]]));
  3870.  
  3871.         // Restore old URL list so displaying it has no effect.
  3872.         client.prefs["urls.list"] = oldList;
  3873.     }
  3874. }
  3875.